home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #1 / Amiga Plus CD - 2000 - No. 1.iso / Tools / Dev / Meshwriter / meshwriter.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-03  |  110.8 KB  |  4,261 lines
  1. /*
  2. **      $VER: meshwriter.c 0.02 (28.3.1999)
  3. **
  4. **      Creation date     : 18.10.1998
  5. **
  6. **      Description       :
  7. **         Mesh writer functions module
  8. **
  9. **
  10. **      Written by Stephan Bielmann
  11. **
  12. */
  13.  
  14. #define __USE_SYSBASE        // perhaps only recognized by SAS/C
  15.  
  16. /*************************** Includes *******************************/
  17.  
  18. /*
  19. ** ANSI standart includes
  20. */
  21. #include <string.h>
  22. #include <math.h>
  23.  
  24. /*
  25. ** Amiga includes
  26. */
  27. #include <exec/types.h>
  28. #include <exec/memory.h>
  29. #include <dos/stdio.h>
  30.  
  31. #include <clib/dos_protos.h>
  32. #include <clib/alib_stdio_protos.h>
  33.  
  34. #include <pragma/exec_lib.h>
  35.  
  36. /*
  37. ** Project includes
  38. */
  39. #include <meshwriter_private.h>
  40.  
  41. #include "raw.h"
  42. #include "vrml1.h"
  43. #include "dxf.h"
  44. #include "pov3.h"
  45. #include "imagine.h"
  46. #include "reflections.h"
  47. #include "lightwave.h"
  48. #include "geo.h"
  49. //#include "real.h"
  50. //#include "postscript.h"
  51.  
  52. #include "compiler.h"
  53.  
  54. /********************** Private constants ***************************/
  55.  
  56. /*
  57. ** The constant supported file format arrays
  58. */
  59. static ULONG  c3dFFIDs [] = {
  60.     T3DFDXF,
  61.     T3DFTDDD,
  62.     T3DFTDDDH,
  63.     T3DFLWOB,
  64.     T3DFPOV3,
  65.     T3DFRAWA,
  66.     T3DFRAWB,
  67. //    T3DFREAL,
  68.     T3DFREF4,
  69.     T3DFGEOA,
  70.     T3DFVRML1,
  71.     0
  72. };
  73.  
  74. static STRPTR c3dFFNames [] = {
  75.     "AutoCAD DXF",
  76.     "Imagine original",
  77.     "Imagine huge",
  78.     "Lightwave",
  79.     "POVRay 3.X",
  80.     "RAW ASCII",
  81.     "RAW binary",
  82. //    "Real 3D",
  83.     "Reflections 4.X",
  84.     "Videoscape ASCII",
  85.     "VRML 1",
  86.     NULL
  87. };
  88.  
  89. static STRPTR c3dFFExtensions [] = {
  90.     "dxf",
  91.     "iob",
  92.     "iob",
  93.     "lwob",
  94.     "pov",
  95.     "raw",
  96.     "raw",
  97. //    "real",
  98.     "r4",
  99.     "geo",
  100.     "wrl",
  101.     NULL
  102. };
  103.  
  104. static ULONG  c2dFFIDs   [] = {
  105. //    T2DFEPS,
  106. //    T2DFPSP,
  107. //    T2DFPSL,
  108.     0
  109. };
  110.  
  111. static STRPTR c2dFFNames [] = {
  112. //    "Encapsulated PostScript",
  113. //    "PostScript portrait",
  114. //    "PostScript landscape",
  115.     NULL
  116. };
  117.  
  118. static STRPTR c2dFFExtensions [] = {
  119. //    "eps",
  120. //    "ps",
  121. //    "ps",
  122.     NULL
  123. };
  124.  
  125.  
  126. /*
  127. ** The constant supported drawing mode arrays
  128. */
  129. static ULONG  cDMIDs   [] = {
  130. //    TDMPOINTS,
  131. //    TDMGRIDBW,
  132. //    TDMGRIDGR,
  133. //    TDMGRIDCL,
  134. //    TDMSURFBW,
  135. //    TDMSURFGR,
  136. //    TDMSURFCL,
  137.     0
  138. };
  139.  
  140. static STRPTR  cDMNames   [] = {
  141. //    "Points, black and white",
  142. //    "Grid, black and white",
  143. //    "Grid, gray scales",
  144. //    "Grid, colors",
  145. //    "Surface, black and white",
  146. //    "Surface, gray scales",
  147. //    "Surface, colors",
  148.     0
  149. };
  150.  
  151. /*
  152. ** Definition of PI
  153. */
  154. #define PI 3.14159265359
  155.  
  156. /********************** Private functions ***************************/
  157.  
  158. /********************************************************************\
  159. *                                                                    *
  160. * Name         : hash                                                *
  161. *                                                                    *
  162. * Description  : Calculates the hashcode of a vertex.                *
  163. *                                                                    *
  164. * Arguments    : vertex IN : The vertex to hash.                     *
  165. *                                                                    *
  166. * Return Value : hashcode                                            *
  167. *                                                                    *
  168. * Comment      :                                                     *
  169. *                                                                    *
  170. \********************************************************************/
  171. static ULONG hash(TOCLVertex vertex) {
  172.     DOUBLE  hx = vertex.x*12.3;
  173.     DOUBLE  hy = vertex.y*23.4;
  174.     DOUBLE  hz = vertex.z*34.5;
  175.  
  176.     return (((ULONG) (pow(hx*hx + hy*hy + hz*hz,0.5) * 9.87)) % HASHSIZE);
  177. }
  178.  
  179. /********************************************************************\
  180. *                                                                    *
  181. * Name         : addVertex                                           *
  182. *                                                                    *
  183. * Description  : Adds the vertex to the mesh, if not already in its  *
  184. *                internal list. And returns the pointer to it.       *
  185. *                The vertex will be transformed according the mehs   *
  186. *                its CTM.
  187. *                                                                    *
  188. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  189. *                vertex IN : The vertex to add.                      *
  190. *                                                                    *
  191. * Return Value : Pointer to the "new" vertex or NULL if no more      *
  192. *                memory is available.                                *
  193. *                                                                    *
  194. * Comment      :                                                     *
  195. *                                                                    *
  196. \********************************************************************/
  197. static TOCLVertexNode *addVertex(TOCLMesh *mesh,
  198.                                  TOCLVertex vertex) {
  199.  
  200.     ULONG    hashcode        =hash(vertex);
  201.     TOCLHashsVerticesNode    *hlvindex=NULL;
  202.     TOCLVertexNode            *ver=NULL;
  203.     TOCLCTM                ctm;
  204.     TOCLVertex             rvertex;
  205.  
  206.     ctm=mesh->ctm;
  207.  
  208.     /*
  209.     ** Transforming the the vertex according the CTM
  210.     */
  211.     // Scaling
  212.     vertex.x*=ctm.sx,vertex.y*=ctm.sy,vertex.z*=ctm.sz;
  213.  
  214.     //Rotation and translation
  215.     rvertex.x=ctm.m[0][0]*vertex.x+ctm.m[1][0]*vertex.y+ctm.m[2][0]*vertex.z+ctm.m[3][0]; 
  216.     rvertex.y=ctm.m[0][1]*vertex.x+ctm.m[1][1]*vertex.y+ctm.m[2][1]*vertex.z+ctm.m[3][1]; 
  217.     rvertex.z=ctm.m[0][2]*vertex.x+ctm.m[1][2]*vertex.y+ctm.m[2][2]*vertex.z+ctm.m[3][2]; 
  218.  
  219.     /*
  220.     ** Check if the vertex is already in our internal list
  221.     */
  222.     hlvindex=mesh->hashTable[hashcode];
  223.     while(hlvindex!=NULL)
  224.     {
  225.           ver=hlvindex->vertexNode;
  226.  
  227.         if(rvertex.x==ver->vertex.x &&
  228.            rvertex.y==ver->vertex.y &&
  229.            rvertex.z==ver->vertex.z ) {
  230.             /*
  231.             ** Yes, return its pointer
  232.             */
  233.             return (ver);
  234.         }
  235.         hlvindex=hlvindex->next;
  236.     }
  237.     
  238.     /*
  239.     ** No it was not. Add a new one to the list and hash and return it
  240.     */
  241.     ver = AllocPooled(mesh->vertexpool,sizeof(TOCLVertexNode));
  242.     if (ver==NULL) return(NULL);
  243.     
  244.     /* The index begins at 1 ! */
  245.     mesh->vertices.numberOfVertices++;            /* increment the list counter */
  246.     ver->index=mesh->vertices.numberOfVertices;    /* Set the index */
  247.     ver->vertex = rvertex;
  248.     ver->next=NULL;
  249.  
  250.     if(mesh->vertices.firstNode!=NULL) {   /* Check if this is the first vertex to insert or not */
  251.         mesh->vertices.lastNode->next=ver;
  252.         mesh->vertices.lastNode=ver;
  253.     }
  254.     else {
  255.         mesh->vertices.lastNode=ver;
  256.         mesh->vertices.firstNode=ver;
  257.     }
  258.  
  259.     /*
  260.     ** Recalculate the bounding box
  261.     */
  262.     if(vertex.x<mesh->bBox.left)   mesh->bBox.left=rvertex.x;
  263.     if(vertex.x>mesh->bBox.right)  mesh->bBox.right=rvertex.x;
  264.     if(vertex.y<mesh->bBox.rear)   mesh->bBox.rear=rvertex.y;
  265.     if(vertex.y>mesh->bBox.front)  mesh->bBox.front=rvertex.y;
  266.     if(vertex.z<mesh->bBox.bottom) mesh->bBox.bottom=rvertex.z;
  267.     if(vertex.z>mesh->bBox.top)    mesh->bBox.top=rvertex.z;
  268.     
  269.     /*
  270.     ** Add the vertex to the hash table
  271.     */
  272.     hlvindex = AllocMem(sizeof(TOCLHashsVerticesNode),MEMF_FAST);
  273.     if (hlvindex==NULL) {
  274.         FreePooled(mesh->vertexpool,ver,sizeof(TOCLVertexNode));
  275.         return(NULL);
  276.     }
  277.     
  278.     hlvindex->vertexNode=ver;
  279.     hlvindex->next=mesh->hashTable[hashcode];
  280.     mesh->hashTable[hashcode]=hlvindex;
  281.     
  282.     return(ver);
  283. }
  284.  
  285. /********************************************************************\
  286. *                                                                    *
  287. * Name         : getVertex                                           *
  288. *                                                                    *
  289. * Description  : Search a vertex in the list with its index.         *
  290. *                                                                    *
  291. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  292. *                index  IN : The vertex its index.                   *
  293. *                                                                    *
  294. * Return Value : Pointer to the vertex or NULL if not found.         *
  295. *                                                                    *
  296. * Comment      :                                                     *
  297. *                                                                    *
  298. \********************************************************************/
  299. static TOCLVertexNode *getVertex(TOCLMesh *mesh,
  300.                                 ULONG index) {
  301.  
  302.     TOCLVertexNode            *ver=NULL;
  303.  
  304.     if(index==0) return(NULL);
  305.  
  306.     ver=mesh->vertices.firstNode;
  307.     while(ver!=NULL && ver->index!=index) {
  308.         ver=ver->next;
  309.     }
  310.  
  311.     return(ver);
  312. }
  313.  
  314. /********************************************************************\
  315. *                                                                    *
  316. * Name         : getVertexIndex                                      *
  317. *                                                                    *
  318. * Description  : Search the index of a vertex in the list with its   *
  319. *                coordinates.                                        *
  320. *                                                                    *
  321. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  322. *                vertex IN : The vertex to search for.               *
  323. *                                                                    *
  324. * Return Value : Index to the vertex or 0 if not found.              *
  325. *                                                                    *
  326. * Comment      :                                                     *
  327. *                                                                    *
  328. \********************************************************************/
  329. static ULONG getVertexIndex(TOCLMesh *mesh,
  330.                             TOCLVertex vertex) {
  331.  
  332.     ULONG    hashcode        =hash(vertex);
  333.     TOCLHashsVerticesNode    *hlvindex=NULL;
  334.     TOCLVertexNode            *ver=NULL;
  335.  
  336.     /*
  337.     ** Check if the vertex is already in our internal list
  338.     */
  339.     hlvindex=mesh->hashTable[hashcode];
  340.     while(hlvindex!=NULL)
  341.     {
  342.           ver=hlvindex->vertexNode;
  343.  
  344.         if(vertex.x==ver->vertex.x &&
  345.            vertex.y==ver->vertex.y &&
  346.            vertex.z==ver->vertex.z ) {
  347.             /*
  348.             ** Yes, return its index
  349.             */
  350.             return (ver->index);
  351.         }
  352.         hlvindex=hlvindex->next;
  353.     }
  354.     
  355.     /*
  356.     ** No it was not.
  357.     */
  358.     return(0);
  359. }
  360.  
  361. /********************************************************************\
  362. *                                                                    *
  363. * Name         : getMaterialNode                                     *
  364. *                                                                    *
  365. * Description  : Search the material its node with its index, in     *
  366. *                the given mesh. If the index=0 or not valid, NULL   *
  367. *                will be returned.                                   *
  368. *                                                                    *
  369. * Arguments    : mesh          IN : Pointer to the mesh.             *
  370. *                materialindex IN : Material index.                  *
  371. *                                                                    *
  372. * Return Value : Pointer to the material or NULL if not found.       *
  373. *                                                                    *
  374. * Comment      :                                                     *
  375. *                                                                    *
  376. \********************************************************************/
  377. static TOCLMaterialNode *getMaterialNode(TOCLMesh *mesh, ULONG materialindex) {
  378.     TOCLMaterialNode    *mindex=NULL;
  379.     
  380.     if(materialindex==0 || materialindex>mesh->materials.numberOfMaterials) return(NULL);
  381.     
  382.     /*
  383.     ** Search the material
  384.     */
  385.     mindex=mesh->materials.firstNode;
  386.     while(mindex!=NULL) {
  387.         if(mindex->index==materialindex) return(mindex);
  388.         
  389.         mindex=mindex->next;
  390.     }
  391.  
  392.     /*
  393.     ** Not found
  394.     */    
  395.     return(NULL);
  396. }
  397.  
  398. /********************************************************************\
  399. *                                                                    *
  400. * Name         : setCameraLight                                      *
  401. *                                                                    *
  402. * Description  : Sets the default position of the camera and the     *
  403. *                light and the camera its view point and the color   *
  404. *                of the light source.                                *
  405. *                                                                    *
  406. * Arguments    : mesh      IN/OUT : Pointer to the mesh.             *
  407. *                                                                    *
  408. * Comment      :                                                     *
  409. *                                                                    *
  410. \********************************************************************/
  411. static VOID setCameraLight(TOCLMesh *mesh) {
  412.     TOCLVertex ver1;
  413.         
  414.     if (mesh==NULL) return;
  415.  
  416.     /* camera its look at position */
  417.     mesh->camera.lookat.x = (mesh->bBox.left + mesh->bBox.right) / 2;
  418.     mesh->camera.lookat.y = (mesh->bBox.front + mesh->bBox.rear) / 2;
  419.     mesh->camera.lookat.z = (mesh->bBox.top + mesh->bBox.bottom) / 2;
  420.     
  421.     /* direction vector */
  422.     ver1.x = mesh->bBox.right - mesh->camera.lookat.x;
  423.     ver1.y = mesh->bBox.front - mesh->camera.lookat.y;
  424.     ver1.z = mesh->bBox.top - mesh->camera.lookat.z;
  425.     
  426.     ver1.x*=2.5;
  427.     ver1.y*=2.5;    
  428.     ver1.z*=2.5;
  429.     
  430.     /* camera its position */
  431.     mesh->camera.position.x = ver1.x + mesh->camera.lookat.x;
  432.     mesh->camera.position.y = ver1.y + mesh->camera.lookat.y;
  433.     mesh->camera.position.z = ver1.z + mesh->camera.lookat.z;
  434.  
  435.     /* light source its position */
  436.     mesh->light.position.x = ver1.x + mesh->camera.lookat.x;
  437.     mesh->light.position.y = ver1.x + mesh->camera.lookat.x;
  438.     mesh->light.position.z = ver1.x + mesh->camera.lookat.x;
  439.     
  440.     /* light source its color */
  441.     mesh->light.color.r=255;
  442.     mesh->light.color.g=255;
  443.     mesh->light.color.b=255;
  444. }
  445.  
  446. /********************************************************************\
  447. *                                                                    *
  448. * Name         : mul33Matrix                                         *
  449. *                                                                    *
  450. * Description  : Multiplicates two 3x3 matrix structures.            *
  451. *                                                                    *
  452. * Arguments    : m1  IN/OUT : The first matrix, contains the result  *
  453. *                m2  IN     : The second matrix.                     *
  454. *                                                                    *
  455. * Comment      :                                                     *
  456. *                                                                    *
  457. \********************************************************************/
  458. void mulMatrix (double m1[3][3], double m2[3][3]) {
  459.     double m[3][3];
  460.     int x,y,yy;
  461.  
  462.     for(x=0;x<3;x++) {
  463.         for(y=0;y<3;y++) {
  464.             m[x][y]=0;
  465.         }
  466.     }
  467.  
  468.     for(x=0;x<3;x++) {
  469.         for(y=0;y<3;y++) {
  470.             for(yy=0;yy<3;yy++) {
  471.                 m[x][y]+=m1[yy][y]*m2[x][yy];
  472.             }
  473.         }
  474.     }
  475.  
  476.     m1[0][0]=m[0][0];
  477.     m1[1][0]=m[1][0];
  478.     m1[2][0]=m[2][0];
  479.     m1[0][1]=m[0][1];
  480.     m1[1][1]=m[1][1];
  481.     m1[2][1]=m[2][1];
  482.     m1[0][2]=m[0][2];
  483.     m1[1][2]=m[1][2];
  484.     m1[2][2]=m[2][2];
  485. }
  486.  
  487. /********************** Public functions ****************************/
  488.  
  489. /****** meshwriter.library/MWLMeshNew ******************************************
  490. * 
  491. *   NAME    
  492. *     MWLMeshNew -- Creates a new mesh
  493. * 
  494. *   SYNOPSIS
  495. *    meshhandle = MWLMeshNew( )
  496. *              
  497. *
  498. *    ULONG MWLMeshNew
  499. *         ( );
  500. *
  501. *   FUNCTION
  502. *    Allocates the memory for a new mesh, initializes all its contents and
  503. *    returns a handle to the new mesh. The mesh has to be deleted after usage
  504. *    with MWLMeshDelete().   
  505. *
  506. *   INPUTS
  507. * 
  508. *   RESULT
  509. *     meshhandle - A handle to the new mesh, or 0 in error case, which means
  510. *                 that there is not enough memory available.
  511. * 
  512. *   EXAMPLE
  513. *
  514. *   NOTES
  515. *
  516. *   BUGS
  517. * 
  518. *   SEE ALSO
  519. *     MWLMeshDelete()
  520. *
  521. *****************************************************************************
  522. *
  523. */
  524. ULONG __saveds ASM MWLMeshNew() {
  525.     TOCLMesh     *mesh=NULL;
  526.     LONG        i;
  527.     UBYTE        buffer[10];
  528.  
  529.     mesh = AllocMem(sizeof(TOCLMesh),MEMF_FAST);
  530.     if (mesh==NULL) return(0);
  531.  
  532.     // create a memory pool for the vertices of this this header
  533.     // ground size of a pool is to get 100 vertices
  534.     mesh->vertexpool=CreatePool(MEMF_FAST,100*sizeof(TOCLVertexNode),100*sizeof(TOCLVertexNode));
  535.     if(mesh->vertexpool==NULL) {
  536.         FreeMem(mesh,sizeof(TOCLMesh));
  537.         return(0);
  538.     }
  539.  
  540.     // create a memory pool for the polygon nodes of this this header
  541.     // ground size of a pool is to get 100 polygons
  542.     mesh->polygonpool=CreatePool(MEMF_FAST,100*sizeof(TOCLPolygonNode),100*sizeof(TOCLPolygonNode));
  543.     if(mesh->polygonpool==NULL) {
  544.         DeletePool(mesh->vertexpool);
  545.         FreeMem(mesh,sizeof(TOCLMesh));
  546.         return(0);
  547.     }
  548.  
  549.     // create a memory pool for the polygon vertex nodes of this this header
  550.     // ground size of a pool is to get 100 polygon vertices
  551.     mesh->polygonverticespool=CreatePool(MEMF_FAST,100*sizeof(TOCLPolygonsVerticesNode),100*sizeof(TOCLPolygonsVerticesNode));
  552.     if(mesh->polygonverticespool==NULL) {
  553.         DeletePool(mesh->polygonpool);
  554.         DeletePool(mesh->vertexpool);
  555.         FreeMem(mesh,sizeof(TOCLMesh));
  556.         return(0);
  557.     }
  558.  
  559.     mesh->name=NULL;
  560.     strcpy(buffer,"NONAME");
  561.     mesh->name = AllocVec(strlen(buffer)+1,MEMF_FAST);
  562.     if (mesh->name==NULL) {
  563.         DeletePool(mesh->polygonverticespool);
  564.         DeletePool(mesh->polygonpool);
  565.         DeletePool(mesh->vertexpool);
  566.         FreeMem(mesh,sizeof(TOCLMesh));
  567.         return(0);
  568.     }
  569.     strcpy(mesh->name,buffer);
  570.     
  571.     mesh->copyright=NULL;
  572.  
  573.     mesh->bBox.left=0.0;
  574.     mesh->bBox.right=0.0;
  575.     mesh->bBox.front=0.0;
  576.     mesh->bBox.rear=0.0;
  577.     mesh->bBox.top=0.0;
  578.     mesh->bBox.bottom=0.0;
  579.     
  580.     mesh->camera.position.x=0.0;
  581.     mesh->camera.position.y=0.0;
  582.     mesh->camera.position.z=0.0;
  583.     mesh->camera.lookat.x=0.0;
  584.     mesh->camera.lookat.y=0.0;
  585.     mesh->camera.lookat.z=0.0;
  586.     
  587.     mesh->light.position.x=0.0;
  588.     mesh->light.position.y=0.0;
  589.     mesh->light.position.z=0.0;
  590.     mesh->light.color.r=255;
  591.     mesh->light.color.g=255;
  592.     mesh->light.color.b=255;
  593.         
  594.     mesh->vertices.numberOfVertices=0;
  595.     mesh->vertices.firstNode=NULL;
  596.     mesh->vertices.lastNode=NULL;
  597.         
  598.     mesh->polygons.numberOfPolygons=0;
  599.     mesh->polygons.firstNode=NULL;
  600.     mesh->polygons.lastNode=NULL;
  601.     
  602.     mesh->materials.numberOfMaterials=0;
  603.     mesh->materials.firstNode=NULL;
  604.     mesh->materials.lastNode=NULL;
  605.  
  606.     mesh->ctm.sx=1,mesh->ctm.sy=1,mesh->ctm.sz=1;
  607.     mesh->ctm.rx=0,mesh->ctm.ry=0,mesh->ctm.rz=0;
  608.     mesh->ctm.m[0][0]=1,mesh->ctm.m[1][0]=0,mesh->ctm.m[2][0]=0,mesh->ctm.m[3][0]=0;
  609.     mesh->ctm.m[0][1]=0,mesh->ctm.m[1][1]=1,mesh->ctm.m[2][1]=0,mesh->ctm.m[3][1]=0;
  610.     mesh->ctm.m[0][2]=0,mesh->ctm.m[1][2]=0,mesh->ctm.m[2][2]=1,mesh->ctm.m[3][2]=0;
  611.     mesh->ctm.m[0][3]=0,mesh->ctm.m[1][3]=0,mesh->ctm.m[2][3]=0,mesh->ctm.m[3][3]=1;
  612.     
  613.     for(i=0;i<HASHSIZE;i++) mesh->hashTable[i]=NULL;
  614.     
  615.     return(ULONG)mesh;
  616. }
  617.  
  618. /****** meshwriter.library/MWLMeshDelete ******************************************
  619. * 
  620. *   NAME    
  621. *     MWLMeshDelete -- Delete a mesh which was created whith MWLMeshNew() before.
  622. * 
  623. *   SYNOPSIS
  624. *    error = MWLMeshDelete( meshhandle )
  625. *                           D1
  626. *
  627. *    ULONG MWLMeshDelete
  628. *         ( ULONG );
  629. *
  630. *   FUNCTION
  631. *    Free the memory occupied by the mesh, and delete the mesh itself.
  632. * 
  633. *   INPUTS
  634. *     meshhandle    - A valid handle of a mesh.
  635. *    
  636. *   RESULT
  637. *     error - RCNOERROR if all went well.
  638. *            RCNOMESH  if the handle is not valid.
  639. *
  640. *   EXAMPLE
  641. * 
  642. *   NOTES
  643. *    Can take some time.
  644. *
  645. *   BUGS
  646. * 
  647. *   SEE ALSO
  648. *     MWLMeshNew()
  649. * 
  650. ******************************************************************************
  651. *
  652. */
  653. ULONG __saveds ASM MWLMeshDelete(register __d1 ULONG meshhandle) {
  654.     TOCLMesh                    *mesh=NULL;
  655.     TOCLVertexNode                *ver=NULL, *vindex=NULL;
  656.     TOCLPolygonNode            *pln=NULL, *plnindex=NULL;
  657.     TOCLPolygonsVerticesNode    *plv=NULL, *plvindex=NULL;
  658.     TOCLMaterialNode            *mat=NULL, *mindex=NULL;
  659.     TOCLHashsVerticesNode        *hlv=NULL, *hlvindex=NULL;
  660.     ULONG                        i;
  661.         
  662.     mesh=(TOCLMesh *) meshhandle;
  663.     if(mesh==NULL) return(RCNOMESH);
  664.  
  665.     /*
  666.     ** Free the name string
  667.     */
  668.     FreeVec(mesh->name);
  669.  
  670.     /*
  671.     ** Free the copyright string
  672.     */ 
  673.     FreeVec(mesh->copyright);
  674.  
  675.     /*
  676.     ** Free the vertices
  677.     */
  678.     DeletePool(mesh->vertexpool);
  679.  
  680.     /*
  681.     ** Free the polygon vertices
  682.     */
  683.     DeletePool(mesh->polygonverticespool);
  684.  
  685.     /*
  686.     ** Free the polygons
  687.     */
  688.     DeletePool(mesh->polygonpool);
  689.     
  690.     /*
  691.     ** Free the materials
  692.     */
  693.     mindex=mesh->materials.firstNode;
  694.     while(mindex!=NULL) {
  695.         mat=mindex;
  696.         mindex=mindex->next;
  697.         
  698.         /*
  699.         ** Free the name string
  700.         */
  701.         FreeVec(mat->name);
  702.         
  703.         FreeMem(mat,sizeof(TOCLMaterialNode));
  704.     }
  705.  
  706.     /*
  707.     ** Free the hashtable entries
  708.     */
  709.     for(i=0;i<HASHSIZE;i++) {
  710.         hlvindex=mesh->hashTable[i];
  711.         while(hlvindex!=NULL) {
  712.             hlv=hlvindex;
  713.             hlvindex=hlvindex->next;
  714.             FreeMem(hlv,sizeof(TOCLHashsVerticesNode));
  715.         }        
  716.     }
  717.  
  718.     /*
  719.     ** Free the mesh itself
  720.     */
  721.     FreeMem(mesh,sizeof(TOCLMesh));
  722.  
  723.     return(RCNOERROR);
  724. }
  725.  
  726. /****** meshwriter.library/MWLMeshNameSet ******************************************
  727. * 
  728. *   NAME    
  729. *     MWLMeshNameSet -- Set the name of the mesh.
  730. * 
  731. *   SYNOPSIS
  732. *    error = MWLMeshNameSet( meshhandle,name )
  733. *                            D1         D2
  734. *
  735. *    ULONG MWLMeshNameSet
  736. *         ( ULONG,STRPTR );
  737. *
  738. *   FUNCTION
  739. *    A copy of the passed string will be made and assigned to the mesh its
  740. *    name string.
  741. * 
  742. *   INPUTS
  743. *     meshhandle      - A valid handle of a mesh.
  744. *    name            - String which contains the name.
  745. *    
  746. *   RESULT
  747. *     error - RCNOERROR  if all went well.
  748. *            RCNOMESH   if the handle is not valid.
  749. *             RCNOMEMORY if there is not enough memory.
  750. *
  751. *   EXAMPLE
  752. *    error = MWLMeshNameSet(meshhandle,"GreatShape");
  753. *
  754. *   NOTES
  755. *    This function can be called as often as you need, which will
  756. *    replace the old value.
  757. *
  758. *    Not all formats support names, and the written length of the
  759. *    string depends of the format too.
  760. *
  761. *   BUGS
  762. * 
  763. *   SEE ALSO
  764. *     MWLMeshNameGet()
  765. * 
  766. ******************************************************************************
  767. *
  768. */
  769. ULONG __saveds ASM MWLMeshNameSet(register __d1 ULONG meshhandle,register __d2 STRPTR name ) {
  770.     TOCLMesh *mesh=NULL;
  771.   
  772.     mesh=(TOCLMesh *) meshhandle;
  773.     if (mesh==NULL) return(RCNOMESH);
  774.  
  775.     /*
  776.     ** If the name was already set before, free it
  777.     */
  778.     if (mesh->name) FreeVec(mesh->name);
  779.     mesh->name=NULL;
  780.  
  781.     mesh->name=(STRPTR) AllocVec(strlen(name)+1,MEMF_FAST);
  782.     if(mesh->name==NULL) return(RCNOMEMORY);
  783.   
  784.     strcpy(mesh->name,name);
  785.   
  786.     return(RCNOERROR);
  787. }
  788.  
  789. /****** meshwriter.library/MWLMeshNameGet ******************************************
  790. * 
  791. *   NAME    
  792. *     MWLMeshNameGet -- Get the name of a mesh.
  793. *
  794. *   SYNOPSIS
  795. *    error = MWLMeshNameGet( meshhandle,name )
  796. *                            D1         D2
  797. *
  798. *    ULONG MWLMeshNameGet
  799. *         ( ULONG,STRPTR * );
  800. *
  801. *   FUNCTION
  802. *    You will get a pointer to the name of the mesh. This string is READ_ONLY
  803. *    and only valid as long the as mesh exists.
  804. * 
  805. *   INPUTS
  806. *     meshhandle    - A valid handle of a mesh.
  807. *    name          - Pointer to the name of the mesh.
  808. *    
  809. *   RESULT
  810. *     error - RCNOERROR if all went well.
  811. *            RCNOMESH  if the handle is not valid.
  812. * 
  813. *   EXAMPLE
  814. *    error = MWLMeshNameGet(meshhandle,&mystring);
  815. *
  816. *   NOTES
  817. *
  818. *   BUGS
  819. * 
  820. *   SEE ALSO
  821. *     MWLMeshNameSet()
  822. * 
  823. ******************************************************************************
  824. *
  825. */
  826. ULONG __saveds ASM MWLMeshNameGet(register __d1 ULONG meshhandle, register __d2 STRPTR *name) {
  827.     TOCLMesh *mesh=NULL;
  828.   
  829.     mesh=(TOCLMesh *) meshhandle;
  830.     if (mesh==NULL) return(RCNOMESH);
  831.  
  832.     (*name)=mesh->name;
  833.  
  834.     return(RCNOERROR);
  835. }
  836.  
  837. /****** meshwriter.library/MWLMeshCopyrightSet ******************************************
  838. * 
  839. *   NAME    
  840. *     MWLMeshCopyrightSet -- Set the copyright of the mesh.
  841. * 
  842. *   SYNOPSIS
  843. *    error = MWLMeshCopyrightSet( meshhandle,copyright )
  844. *                                 D1         D2
  845. *
  846. *    ULONG MWLMeshCopyrightSet
  847. *         ( ULONG,STRPTR );
  848. *
  849. *   FUNCTION
  850. *    A copy of the passed string will be made and assigned to the mesh its
  851. *    copyright string.
  852. * 
  853. *   INPUTS
  854. *     meshhandle      - A valid handle of a mesh.
  855. *    copyright       - String which contains the copyright.
  856. *    
  857. *   RESULT
  858. *     error - RCNOERROR  if all went well.
  859. *            RCNOMESH   if the handle is not valid.
  860. *             RCNOMEMORY if there is not enough memory.
  861. *
  862. *   EXAMPLE
  863. *    error = MWLMeshCopyrightSet(meshhandle,"This mesh was created with GreatShaper V2.0 for Beethoven");
  864. *
  865. *   NOTES
  866. *    This should be only a single line !
  867. *
  868. *    This function can be called as often as you need, which will replace
  869. *    the old value.
  870. *
  871. *    Not all formats support copyrights, and the written length of the
  872. *    string depends of the format too.
  873. *
  874. *   BUGS
  875. * 
  876. *   SEE ALSO
  877. *     MWLMeshCopyrightGet()
  878. * 
  879. ******************************************************************************
  880. *
  881. */
  882. ULONG __saveds ASM MWLMeshCopyrightSet(register __d1 ULONG meshhandle,register __d2 STRPTR copyright) {
  883.     TOCLMesh *mesh=NULL;
  884.   
  885.     mesh=(TOCLMesh *) meshhandle;
  886.     if (mesh==NULL) return(RCNOMESH);
  887.     
  888.     /*
  889.     ** If the copyright was already set before, free it
  890.     */
  891.     if (mesh->copyright) FreeVec(mesh->copyright);
  892.     mesh->copyright=NULL;
  893.   
  894.     mesh->copyright=(STRPTR) AllocVec(strlen(copyright)+1,MEMF_FAST);
  895.     if(mesh->copyright==NULL) return(RCNOMEMORY);
  896.   
  897.     strcpy(mesh->copyright,copyright);
  898.   
  899.     return(RCNOERROR);
  900. }
  901.  
  902. /****** meshwriter.library/MWLMeshCopyrightGet ******************************************
  903. * 
  904. *   NAME    
  905. *     MWLMeshCopyrightGet -- Get the copyright of a mesh.
  906. *
  907. *   SYNOPSIS
  908. *    error = MWLMeshCopyrightGet( meshhandle,copyright )
  909. *                                 D1         D2
  910. *
  911. *    ULONG MWLMeshCopyrightGet
  912. *         ( ULONG,STRPTR * );
  913. *
  914. *   FUNCTION
  915. *    You will get a pointer to the copyright of the mesh. This string is READ_ONLY
  916. *    and only valid as long as the mesh exists.
  917. * 
  918. *   INPUTS
  919. *     meshhandle    - A valid handle of a mesh.
  920. *    copyright     - Pointer to the copyright of the mesh.
  921. *    
  922. *   RESULT
  923. *     error - RCNOERROR if all went well.
  924. *            RCNOMESH  if the handle is not valid.
  925. * 
  926. *   EXAMPLE
  927. *    error = MWLMeshCopyrightGet(meshhandle,&mystring);
  928. *
  929. *   NOTES
  930. *
  931. *   BUGS
  932. * 
  933. *   SEE ALSO
  934. *     MWLMeshCopyrightSet()
  935. * 
  936. ******************************************************************************
  937. *
  938. */
  939. ULONG __saveds ASM MWLMeshCopyrightGet(register __d1 ULONG meshhandle, register __d2 STRPTR *copyright) {
  940.     TOCLMesh *mesh=NULL;
  941.   
  942.     mesh=(TOCLMesh *) meshhandle;
  943.     if (mesh==NULL) return(RCNOMESH);
  944.     
  945.     (*copyright)=mesh->copyright;
  946.     
  947.     return(RCNOERROR);
  948. }
  949.  
  950. /****** meshwriter.library/MWLMeshMaterialAdd ******************************************
  951. * 
  952. *   NAME    
  953. *     MWLMeshMaterialAdd -- Add a new material to the mesh.
  954. *
  955. *   SYNOPSIS
  956. *    error = MWLMeshMaterialAdd( meshhandle,materialhandle )
  957. *                                D1         D2
  958. *
  959. *    ULONG MWLMeshMaterialAdd
  960. *         ( ULONG,ULONG * );
  961. *
  962. *   FUNCTION
  963. *    A new material will be created and added to the mesh. You will get a handle to it.
  964. *    All material properties will be set to 0.
  965. * 
  966. *   INPUTS
  967. *     meshhandle     - A valid handle of a mesh.
  968. *    materialhandle - Pointer to a variable which will contain 
  969. *                     the handle to the new material.
  970. *    
  971. *   RESULT
  972. *     error - RCNOERROR  if all went well.
  973. *            RCNOMESH   if the handle is not valid.
  974. *            RCNOMEMORY if there is not enough memory. 
  975. * 
  976. *   EXAMPLE
  977. *    error = MWLMeshMaterialAdd(meshhandle,&mylong);
  978. *
  979. *   NOTES
  980. *    A default name will be assigned to the new material.
  981. *    Like MWLMATX, where X is an internal count of the material.
  982. *
  983. *   BUGS
  984. * 
  985. *   SEE ALSO
  986. *     MWLMeshMaterialNameSet(),MWLMeshMaterialAmbientColorSet(),
  987. *   MWLMeshMaterialDiffuseColorSet(),MWLMeshMaterialShininessSet()
  988. *    MWLMeshMaterialTransparencySet()
  989. * 
  990. ******************************************************************************
  991. *
  992. */
  993. ULONG __saveds ASM MWLMeshMaterialAdd(register __d1 ULONG meshhandle, register __d2 ULONG *materialhandle) {
  994.     TOCLMesh            *mesh=NULL;
  995.     TOCLMaterialNode    *mat=NULL;
  996.     UBYTE                buffer[100];
  997.     
  998.     mesh=(TOCLMesh *) meshhandle;
  999.     if(mesh==NULL) return(RCNOMESH);
  1000.  
  1001.     (*materialhandle)=0;
  1002.  
  1003.     mat = AllocMem(sizeof(TOCLMaterialNode),MEMF_FAST);
  1004.     if (mat==NULL) return(RCNOMEMORY);
  1005.  
  1006.     mat->index=++mesh->materials.numberOfMaterials; /*Index begins at 1 */
  1007.    (*materialhandle)=mat->index;
  1008.  
  1009.     mat->name=NULL;
  1010.     sprintf(buffer,"MWLMAT%ld",mat->index);
  1011.     mat->name = AllocVec(strlen(buffer)+1,MEMF_FAST);
  1012.     if (mat->name==NULL) {
  1013.         FreeMem(mat,sizeof(TOCLMaterialNode));
  1014.         return(RCNOMEMORY);
  1015.     }
  1016.     strcpy(mat->name,buffer);
  1017.     
  1018.     mat->ambientColor.r=0;
  1019.     mat->ambientColor.g=0;
  1020.     mat->ambientColor.b=0;
  1021.     mat->diffuseColor.r=0;
  1022.     mat->diffuseColor.g=0;
  1023.     mat->diffuseColor.b=0;
  1024.     mat->shininess=0;
  1025.     mat->transparency=0;
  1026.     mat->next=NULL;
  1027.  
  1028.     if(mesh->materials.firstNode!=NULL) {   /* Check if this is the first material to insert or not */
  1029.         mesh->materials.lastNode->next=mat;
  1030.         mesh->materials.lastNode=mat;
  1031.     }
  1032.     else {
  1033.         mesh->materials.lastNode=mat;
  1034.         mesh->materials.firstNode=mat;
  1035.     }
  1036.  
  1037.     return(RCNOERROR);
  1038. }
  1039.  
  1040. /****** meshwriter.library/MWLMeshMaterialNameSet ******************************************
  1041. * 
  1042. *   NAME    
  1043. *     MWLMeshMaterialNameSet -- Set the name of the material.
  1044. * 
  1045. *   SYNOPSIS
  1046. *    error = MWLMeshMaterialNameSet( meshhandle,materialhandle,materialname )
  1047. *                                    D1         D2             D3
  1048. *
  1049. *    ULONG MWLMeshMaterialNameSet
  1050. *         ( ULONG,ULONG,STRPTR );
  1051. *
  1052. *   FUNCTION
  1053. *    A copy of the passed string will be made and assigned to the material its
  1054. *    name string.
  1055. * 
  1056. *   INPUTS
  1057. *     meshhandle      - A valid handle of a mesh.
  1058. *    materialhandle  - A valid handle of a material.
  1059. *    materialname    - String which contains the name.
  1060. *    
  1061. *   RESULT
  1062. *     error - RCNOERROR    if all went well.
  1063. *            RCNOMESH     if the handle is not valid.
  1064. *            RCNOMATERIAL if the handle is not valid.
  1065. *             RCNOMEMORY   if there is not enough memory.
  1066. *
  1067. *   EXAMPLE
  1068. *    error = MWLMeshMaterialNameSet(meshhandle,materialhandle,"DeepBlue");
  1069. *
  1070. *   NOTES
  1071. *    This function can be called as often as you need which will
  1072. *    replace the old value.
  1073. *
  1074. *    Not all formats support names, and the written length of the
  1075. *    string depends of the format too.
  1076. *
  1077. *   BUGS
  1078. * 
  1079. *   SEE ALSO
  1080. *     MWLMeshMaterialNameGet()
  1081. * 
  1082. ******************************************************************************
  1083. *
  1084. */
  1085. ULONG __saveds ASM MWLMeshMaterialNameSet(register __d1 ULONG meshhandle,
  1086.                                                 register __d2 ULONG materialhandle,
  1087.                                                 register __d3 STRPTR materialname) {
  1088.     TOCLMesh            *mesh=NULL;
  1089.     TOCLMaterialNode    *mat=NULL;
  1090.   
  1091.     mesh=(TOCLMesh *) meshhandle;
  1092.     if(mesh==NULL) return(RCNOMESH);
  1093.  
  1094.     mat=getMaterialNode(mesh,materialhandle);
  1095.     if(mat==NULL) return(RCNOMATERIAL);
  1096.  
  1097.     /*
  1098.     ** If the name was already set before, free it
  1099.     */
  1100.     if (mat->name) FreeVec(mat->name);
  1101.     mat->name=NULL;
  1102.     
  1103.     mat->name=(STRPTR) AllocVec(strlen(materialname)+1,MEMF_FAST);
  1104.     if(mat->name==NULL) return(RCNOMEMORY);
  1105.   
  1106.     strcpy(mat->name,materialname);
  1107.  
  1108.     return(RCNOERROR);
  1109. }
  1110.  
  1111. /****** meshwriter.library/MWLMeshMaterialNameGet ******************************************
  1112. * 
  1113. *   NAME    
  1114. *     MWLMeshMaterialNameGet -- Get the name of a material.
  1115. *
  1116. *   SYNOPSIS
  1117. *    error = MWLMeshMaterialNameGet( meshhandle,materialhandle,name )
  1118. *                                    D1         D2             D3
  1119. *
  1120. *    ULONG MWLMeshMaterialNameGet
  1121. *         ( ULONG,ULONG,STRPTR * );
  1122. *
  1123. *   FUNCTION
  1124. *    You will get a pointer to the name of the material. This string is READ_ONLY
  1125. *    and only valid as long as the mesh exists.
  1126. * 
  1127. *   INPUTS
  1128. *     meshhandle     - A valid handle of a mesh.
  1129. *    materialhandle - A valid handle of a material.
  1130. *    name           - Pointer to the name of the material.
  1131. *    
  1132. *   RESULT
  1133. *     error - RCNOERROR    if all went well.
  1134. *            RCNOMESH     if the handle is not valid.
  1135. *            RCNOMATERIAL if the handle is not valid.
  1136. * 
  1137. *   EXAMPLE
  1138. *    error = MWLMeshMaterialNameGet(meshhandle,materialhandle,&mystring);
  1139. *
  1140. *   NOTES
  1141. *
  1142. *   BUGS
  1143. * 
  1144. *   SEE ALSO
  1145. *     MWLMeshMaterialNameSet()
  1146. * 
  1147. ******************************************************************************
  1148. *
  1149. */
  1150. ULONG __saveds ASM MWLMeshMaterialNameGet(register __d1 ULONG meshhandle,
  1151.                                                 register __d2 ULONG materialhandle,
  1152.                                                 register __d3 STRPTR *name) {
  1153.     TOCLMesh            *mesh=NULL;
  1154.     TOCLMaterialNode    *mat=NULL;
  1155.     
  1156.     mesh=(TOCLMesh *) meshhandle;
  1157.     if(mesh==NULL) return(RCNOMESH);
  1158.  
  1159.     mat=getMaterialNode(mesh,materialhandle);
  1160.     if(mat==NULL) return(RCNOMATERIAL);
  1161.  
  1162.     (*name)=mat->name;
  1163.     
  1164.     return(RCNOERROR);
  1165. }
  1166.  
  1167. /****** meshwriter.library/MWLMeshMaterialAmbientColorSet ******************************************
  1168. * 
  1169. *   NAME    
  1170. *     MWLMeshMaterialAmbientColorSet -- Set the ambient color of a material.
  1171. * 
  1172. *   SYNOPSIS
  1173. *    error = MWLMeshMaterialAmbientColorSet( meshhandle,materialhandle,color )
  1174. *                                            D1         D2              A0
  1175. *
  1176. *    ULONG MWLMeshMaterialAmbientColorSet
  1177. *         ( ULONG,ULONG,TOCLColor * );
  1178. *
  1179. *   FUNCTION
  1180. *    The ambient color of the material will be set to the values passed by the
  1181. *    color structure.
  1182. * 
  1183. *   INPUTS
  1184. *     meshhandle      - A valid handle of a mesh.
  1185. *    materialhandle  - A valid handle of a material.
  1186. *    color           - Pointer to a color structure containing the color information.
  1187. *    
  1188. *   RESULT
  1189. *     error - RCNOERROR    if all went well.
  1190. *            RCNOMESH     if the handle is not valid.
  1191. *            RCNOMATERIAL if the handle is not valid.
  1192. *
  1193. *   EXAMPLE
  1194. *    error = MWLMeshMaterialAmbientColorSet(meshhandle,materialhandle,&mycolor);
  1195. *
  1196. *   NOTES
  1197. *
  1198. *   BUGS
  1199. * 
  1200. *   SEE ALSO
  1201. *     MWLMeshMaterialAmbientColorGet()
  1202. * 
  1203. ******************************************************************************
  1204. *
  1205. */
  1206. ULONG __saveds ASM MWLMeshMaterialAmbientColorSet(register __d1 ULONG meshhandle,
  1207.                                                         register __d2 ULONG materialhandle,
  1208.                                                         register __a0 TOCLColor *color) {
  1209.     TOCLMesh            *mesh=NULL;
  1210.     TOCLMaterialNode    *mat=NULL;
  1211.     TOCLColor            *mcolor=NULL;
  1212.  
  1213.     // make a copy of color, because a0 is a scratch register
  1214.     mcolor = color;
  1215.     
  1216.     mesh=(TOCLMesh *) meshhandle;
  1217.     if(mesh==NULL) return(RCNOMESH);
  1218.   
  1219.     mat=getMaterialNode(mesh,materialhandle);
  1220.     if(mat==NULL) return(RCNOMATERIAL);
  1221.   
  1222.     mat->ambientColor=(*mcolor);
  1223.     
  1224.     return(RCNOERROR);
  1225. }
  1226.  
  1227. /****** meshwriter.library/MWLMeshMaterialAmbientColorGet ******************************************
  1228. * 
  1229. *   NAME    
  1230. *     MWLMeshMaterialAmbientColorGet -- Get the ambient color of a material.
  1231. * 
  1232. *   SYNOPSIS
  1233. *    error = MWLMeshMaterialAmbientColorGet( meshhandle,materialhandle,color )
  1234. *                                            D1         D2              A0
  1235. *
  1236. *    ULONG MWLMeshMaterialAmbientColorGet
  1237. *         ( ULONG,ULONG,TOCLColor * );
  1238. *
  1239. *   FUNCTION
  1240. *    The ambient color of the material will be written in the passed color structure.
  1241. * 
  1242. *   INPUTS
  1243. *     meshhandle      - A valid handle of a mesh.
  1244. *    materialhandle  - A valid handle of a material.
  1245. *    color           - Pointer to a color structure which will contain
  1246. *                      the color information.
  1247. *    
  1248. *   RESULT
  1249. *     error - RCNOERROR    if all went well.
  1250. *            RCNOMESH     if the handle is not valid.
  1251. *            RCNOMATERIAL if the handle is not valid.
  1252. *
  1253. *   EXAMPLE
  1254. *    error = MWLMeshMaterialAmbientColorGet(meshhandle,materialhandle,&mycolor);
  1255. *
  1256. *   NOTES
  1257. *
  1258. *   BUGS
  1259. * 
  1260. *   SEE ALSO
  1261. *     MWLMeshMaterialAmbientColorSet()
  1262. * 
  1263. ******************************************************************************
  1264. *
  1265. */
  1266. ULONG __saveds ASM MWLMeshMaterialAmbientColorGet(register __d1 ULONG meshhandle,
  1267.                                                         register __d2 ULONG materialhandle,
  1268.                                                         register __a0 TOCLColor *color) {
  1269.     TOCLMesh            *mesh=NULL;
  1270.     TOCLMaterialNode    *mat=NULL;
  1271.     TOCLColor            *mcolor=NULL;
  1272.     
  1273.     // make a copy of color, a0 is a scratch register
  1274.     mcolor=color;
  1275.     
  1276.     mesh=(TOCLMesh *) meshhandle;
  1277.     if(mesh==NULL) return(RCNOMESH);
  1278.   
  1279.     mat=getMaterialNode(mesh,materialhandle);
  1280.     if(mat==NULL) return(RCNOMATERIAL);
  1281.   
  1282.     (*mcolor)=mat->ambientColor;
  1283.     
  1284.     return(RCNOERROR);
  1285. }
  1286.  
  1287. /****** meshwriter.library/MWLMeshMaterialShininessSet ******************************************
  1288. * 
  1289. *   NAME    
  1290. *     MWLMeshMaterialShininessSet -- Set the shininess of a material.
  1291. * 
  1292. *   SYNOPSIS
  1293. *    error = MWLMeshMaterialShininessSet( meshhandle,materialhandle,shininess )
  1294. *                                         D1         D2             D3
  1295. *
  1296. *    ULONG MWLMeshMaterialShininessSet
  1297. *         ( ULONG,ULONG,TOCLFloat );
  1298. *
  1299. *   FUNCTION
  1300. *    The shininess of the material will be set to the value passed by
  1301. *    shininess.
  1302. * 
  1303. *   INPUTS
  1304. *     meshhandle      - A valid handle of a mesh.
  1305. *    materialhandle  - A valid handle of a material.
  1306. *    shininess       - Value of the shininess between 0.0 and 1.0.
  1307. *    
  1308. *   RESULT
  1309. *     error - RCNOERROR         if all went well.
  1310. *            RCNOMESH          if the handle is not valid.
  1311. *            RCNOMATERIAL      if the handle is not valid.
  1312. *            RCVALUEOUTOFRANGE if the value is out of range.
  1313. *
  1314. *   EXAMPLE
  1315. *    error = MWLMeshMaterialShininessSet(meshhandle,materialhandle,0.34);
  1316. *
  1317. *   NOTES
  1318. *
  1319. *   BUGS
  1320. * 
  1321. *   SEE ALSO
  1322. *     MWLMeshMaterialShininessGet()
  1323. * 
  1324. ******************************************************************************
  1325. *
  1326. */
  1327. ULONG __saveds ASM MWLMeshMaterialShininessSet(register __d1 ULONG meshhandle,
  1328.                                                     register __d2 ULONG materialhandle,
  1329.                                                     register __d3 TOCLFloat shininess) {
  1330.     TOCLMesh            *mesh=NULL;
  1331.     TOCLMaterialNode    *mat=NULL;
  1332.   
  1333.     mesh=(TOCLMesh *) meshhandle;
  1334.     if(mesh==NULL) return(RCNOMESH);
  1335.  
  1336.     mat=getMaterialNode(mesh,materialhandle);
  1337.     if(mat==NULL) return(RCNOMATERIAL);
  1338.     
  1339.     if(shininess>=0 && shininess <=1) mat->shininess=shininess;
  1340.     else return(RCVALUEOUTOFRANGE);
  1341.     
  1342.     return(RCNOERROR);
  1343. }
  1344.  
  1345. /****** meshwriter.library/MWLMeshMaterialShininessGet ******************************************
  1346. * 
  1347. *   NAME    
  1348. *     MWLMeshMaterialShininessGet -- Get the shininess of a material.
  1349. * 
  1350. *   SYNOPSIS
  1351. *    error = MWLMeshMaterialShininessGet( meshhandle,materialhandle,shininess )
  1352. *                                         D1         D2             D3
  1353. *
  1354. *    ULONG MWLMeshMaterialShininessGet
  1355. *         ( ULONG,ULONG,TOCLFloat * );
  1356. *
  1357. *   FUNCTION
  1358. *    The shininess of the material will be put into the variable pointed by shininess.
  1359. * 
  1360. *   INPUTS
  1361. *     meshhandle      - A valid handle of a mesh.
  1362. *    materialhandle  - A valid handle of a material.
  1363. *    shininess       - Pointer to the variable which will contain the shininess.
  1364. *    
  1365. *   RESULT
  1366. *     error - RCNOERROR         if all went well.
  1367. *            RCNOMESH          if the handle is not valid.
  1368. *            RCNOMATERIAL      if the handle is not valid.
  1369. *
  1370. *   EXAMPLE
  1371. *    error = MWLMeshMaterialShininessGet(meshhandle,materialhandle,&myfloat);
  1372. *
  1373. *   NOTES
  1374. *
  1375. *   BUGS
  1376. * 
  1377. *   SEE ALSO
  1378. *     MWLMeshMaterialShininessSet()
  1379. * 
  1380. ******************************************************************************
  1381. *
  1382. */
  1383. ULONG __saveds ASM MWLMeshMaterialShininessGet(register __d1 ULONG meshhandle,
  1384.                                                     register __d2 ULONG materialhandle,
  1385.                                                     register __d3 TOCLFloat *shininess) {
  1386.     TOCLMesh            *mesh=NULL;
  1387.     TOCLMaterialNode    *mat=NULL;
  1388.   
  1389.     mesh=(TOCLMesh *) meshhandle;
  1390.     if(mesh==NULL) return(RCNOMESH);
  1391.  
  1392.     mat=getMaterialNode(mesh,materialhandle);
  1393.     if(mat==NULL) return(RCNOMATERIAL);
  1394.     
  1395.     (*shininess)=mat->shininess;
  1396.     
  1397.     return(RCNOERROR);
  1398. }
  1399.  
  1400. /****** meshwriter.library/MWLMeshMaterialTransparencySet ******************************************
  1401. * 
  1402. *   NAME    
  1403. *     MWLMeshMaterialTransparencySet -- Set the transparency of a material.
  1404. * 
  1405. *   SYNOPSIS
  1406. *    error = MWLMeshMaterialTransparencySet( meshhandle,materialhandle,transparency )
  1407. *                                            D1         D2             D3
  1408. *
  1409. *    ULONG MWLMeshMaterialTransparencySet
  1410. *         ( ULONG,ULONG,TOCLFloat );
  1411. *
  1412. *   FUNCTION
  1413. *    The transparency of the material will be set to the value passed by
  1414. *    transparency.
  1415. * 
  1416. *   INPUTS
  1417. *     meshhandle      - A valid handle of a mesh.
  1418. *    materialhandle  - A valid handle of a material.
  1419. *    transparency    - Value of the transparency between 0.0 and 1.0.
  1420. *    
  1421. *   RESULT
  1422. *     error - RCNOERROR         if all went well.
  1423. *            RCNOMESH          if the handle is not valid.
  1424. *            RCNOMATERIAL      if the handle is not valid.
  1425. *            RCVALUEOUTOFRANGE if the value is out of range.
  1426. *
  1427. *   EXAMPLE
  1428. *    error = MWLMeshMaterialTransparencySet(meshhandle,materialhandle,0.9);
  1429. *
  1430. *   NOTES
  1431. *
  1432. *   BUGS
  1433. * 
  1434. *   SEE ALSO
  1435. *     MWLMeshMaterialTransparencyGet()
  1436. * 
  1437. ******************************************************************************
  1438. *
  1439. */
  1440. ULONG __saveds ASM MWLMeshMaterialTransparencySet(register __d1 ULONG meshhandle,
  1441.                                                         register __d2 ULONG materialhandle,
  1442.                                                         register __d3 TOCLFloat transparency) {
  1443.     TOCLMesh            *mesh=NULL;
  1444.     TOCLMaterialNode    *mat=NULL;
  1445.   
  1446.     mesh=(TOCLMesh *) meshhandle;
  1447.     if(mesh==NULL) return(RCNOMESH);
  1448.     
  1449.     mat=getMaterialNode(mesh,materialhandle);
  1450.     if(mat==NULL) return(RCNOMATERIAL);
  1451.     
  1452.     if(transparency>=0 && transparency<=1) mat->transparency=transparency;
  1453.     else return(RCVALUEOUTOFRANGE);
  1454.     
  1455.     return(RCNOERROR);
  1456. }
  1457.  
  1458. /****** meshwriter.library/MWLMeshMaterialTransparencyGet ******************************************
  1459. * 
  1460. *   NAME    
  1461. *     MWLMeshMaterialTransparencyGet -- Get the transparency of a material.
  1462. * 
  1463. *   SYNOPSIS
  1464. *    error = MWLMeshMaterialTransparencyGet( meshhandle,materialhandle,transparency )
  1465. *                                            D1         D2             D3
  1466. *
  1467. *    ULONG MWLMeshMaterialTransparencyGet
  1468. *         ( ULONG,ULONG,TOCLFloat * );
  1469. *
  1470. *   FUNCTION
  1471. *    The transparency of the material will be put into the variable pointed by transparency.
  1472. * 
  1473. *   INPUTS
  1474. *     meshhandle      - A valid handle of a mesh.
  1475. *    materialhandle  - A valid handle of a material.
  1476. *    transparency    - Pointer to the variable which will contain the transparency.
  1477. *    
  1478. *   RESULT
  1479. *     error - RCNOERROR         if all went well.
  1480. *            RCNOMESH          if the handle is not valid.
  1481. *            RCNOMATERIAL      if the handle is not valid.
  1482. *
  1483. *   EXAMPLE
  1484. *    error = MWLMeshMaterialTransparencyGet(meshhandle,materialhandle,&myfloat);
  1485. *
  1486. *   NOTES
  1487. *
  1488. *   BUGS
  1489. * 
  1490. *   SEE ALSO
  1491. *     MWLMeshMaterialTransparencySet()
  1492. * 
  1493. ******************************************************************************
  1494. *
  1495. */
  1496. ULONG __saveds ASM MWLMeshMaterialTransparencyGet(register __d1 ULONG meshhandle,
  1497.                                                         register __d2 ULONG materialhandle,
  1498.                                                         register __d3 TOCLFloat *transparency) {
  1499.     TOCLMesh            *mesh=NULL;
  1500.     TOCLMaterialNode    *mat=NULL;
  1501.   
  1502.     mesh=(TOCLMesh *) meshhandle;
  1503.     if(mesh==NULL) return(RCNOMESH);
  1504.     
  1505.     mat=getMaterialNode(mesh,materialhandle);
  1506.     if(mat==NULL) return(RCNOMATERIAL);
  1507.     
  1508.     (*transparency)=mat->transparency;
  1509.     
  1510.     return(RCNOERROR);
  1511. }
  1512.  
  1513. /****** meshwriter.library/MWLMeshPolygonAdd ******************************************
  1514. * 
  1515. *   NAME    
  1516. *     MWLMeshPolygonAdd -- Add a new polygon to the mesh.
  1517. *
  1518. *   SYNOPSIS
  1519. *    error = MWLMeshPolygonAdd( meshhandle,materialhandle )
  1520. *                               D1         D2
  1521. *
  1522. *    ULONG MWLMeshPolygonAdd
  1523. *         ( ULONG,ULONG );
  1524. *
  1525. *   FUNCTION
  1526. *    A new polygon will be created and added to the mesh.
  1527. *    With MWLMeshPolygonVertexAdd you can add vertices to this polygon.
  1528. * 
  1529. *   INPUTS
  1530. *     meshhandle     - A valid handle of a mesh.
  1531. *    materialhandle - A valid handle of a material or 0 if you wont
  1532. *                     assign a material to this polygon now.
  1533. *    
  1534. *   RESULT
  1535. *     error - RCNOERROR    if all went well.
  1536. *            RCNOMESH     if the handle is not valid.
  1537. *            RCNOMATERIAL if the handle is not valid.
  1538. *            RCNOMEMORY   if there is not enough memory. 
  1539. * 
  1540. *   EXAMPLE
  1541. *    error = MWLMeshPolygonAdd(meshhandle,materialhandle);
  1542. *
  1543. *   NOTES
  1544. *    Only convex polygons are supported.
  1545. *
  1546. *        Correct              Incorrect
  1547. *
  1548. *        *-----*              *----*
  1549. *       / \   /                \  /
  1550. *      /   \ /                  \/
  1551. *     / __--*                   /\
  1552. *    *--                       /  \
  1553. *                             *----*
  1554. *
  1555. *   BUGS
  1556. * 
  1557. *   SEE ALSO
  1558. *     MWLMeshPolygonMaterialSet(),MWLMeshPolygonVertexAdd()
  1559. * 
  1560. ******************************************************************************
  1561. *
  1562. */
  1563. ULONG __saveds ASM MWLMeshPolygonAdd(register __d1 ULONG meshhandle,
  1564.                                         register __d2 ULONG materialhandle) {
  1565.     TOCLMesh            *mesh=NULL;
  1566.     TOCLMaterialNode    *mat=NULL;
  1567.     TOCLPolygonNode    *pln=NULL;
  1568.         
  1569.     mesh=(TOCLMesh *) meshhandle;
  1570.     if (mesh==NULL) return(RCNOMESH);
  1571.  
  1572.     mat=getMaterialNode(mesh,materialhandle);
  1573.     if(materialhandle!=0 && mat==NULL) return(RCNOMATERIAL);
  1574.  
  1575.     /*
  1576.     ** Creat a new polygon, add it to the internal list
  1577.     */
  1578.     pln = AllocPooled(mesh->polygonpool,sizeof(TOCLPolygonNode));
  1579.     if (pln==NULL) return(RCNOMEMORY);
  1580.         
  1581.     pln->numberOfVertices=0;
  1582.     pln->firstNode=NULL;
  1583.     pln->lastNode=NULL;
  1584.     pln->next=NULL;
  1585.     pln->materialNode=mat;
  1586.         
  1587.     if(mesh->polygons.firstNode!=NULL) {   /* Check if this is the first polygon to insert or not */
  1588.         mesh->polygons.lastNode->next=pln;
  1589.         mesh->polygons.lastNode=pln;
  1590.     }
  1591.     else {
  1592.         mesh->polygons.lastNode=pln;
  1593.         mesh->polygons.firstNode=pln;
  1594.     }
  1595.  
  1596.     /*
  1597.     ** Increment the polygon counter
  1598.     */
  1599.     mesh->polygons.numberOfPolygons++;
  1600.         
  1601.     return(RCNOERROR);
  1602. }
  1603.  
  1604. /****** meshwriter.library/MWLMeshPolygonMaterialSet ******************************************
  1605. * 
  1606. *   NAME    
  1607. *     MWLMeshPolygonMaterialSet -- Set the material of the most recent polygon.
  1608. * 
  1609. *   SYNOPSIS
  1610. *    error = MWLMeshPolygonMaterialSet( meshhandle,materialhandle )
  1611. *                                       D1         D2
  1612. *
  1613. *    ULONG MWLMeshPolygonMaterialSet
  1614. *         ( ULONG,ULONG );
  1615. *
  1616. *   FUNCTION
  1617. *    The material of the most recent polygon will be set to the one you
  1618. *    pass by the handle.
  1619. * 
  1620. *   INPUTS
  1621. *     meshhandle      - A valid handle of a mesh.
  1622. *    materialhandle  - A valid handle of a material.
  1623. *    
  1624. *   RESULT
  1625. *     error - RCNOERROR    if all went well.
  1626. *            RCNOMESH     if the handle is not valid.
  1627. *            RCNOMATERIAL if the handle is not valid.
  1628. *            RCNOPOLYGON  if there is no polygon to work with.     
  1629. *
  1630. *   EXAMPLE
  1631. *    error = MWLMeshPolygonMaterialSet(meshhandle,materialhandle);
  1632. *
  1633. *   NOTES
  1634. *    As all is a polygon, after calling MWLMeshTriangleAdd() with this
  1635. *    function you can set the material of the new triangle too.
  1636. *
  1637. *   BUGS
  1638. * 
  1639. *   SEE ALSO
  1640. *     MWLMeshPolygonAdd(),MWLMeshTriangleAdd()
  1641. * 
  1642. ******************************************************************************
  1643. *
  1644. */
  1645. ULONG __saveds ASM MWLMeshPolygonMaterialSet(register __d1 ULONG meshhandle,
  1646.                                                 register __d2 ULONG materialhandle) {
  1647.     TOCLMesh            *mesh=NULL;
  1648.     TOCLMaterialNode    *mat=NULL;
  1649.         
  1650.     mesh=(TOCLMesh *) meshhandle;
  1651.     if(mesh==NULL) return(RCNOMESH);
  1652.  
  1653.    if(mesh->polygons.lastNode==NULL) return(RCNOPOLYGON); /* There is no polygon to work with */
  1654.  
  1655.     /*
  1656.     ** Set the material to this polygon
  1657.     */
  1658.     mat=getMaterialNode(mesh,materialhandle);
  1659.     if(materialhandle!=0 && mat==NULL) return(RCNOMATERIAL);
  1660.     
  1661.     mesh->polygons.lastNode->materialNode=mat;
  1662.  
  1663.     return(RCNOERROR);
  1664. }
  1665.  
  1666. /****** meshwriter.library/MWLMeshPolygonVertexAdd ******************************************
  1667. * 
  1668. *   NAME    
  1669. *     MWLMeshPolygonVertexAdd -- Add a new vertex to the most recent polygon,
  1670. *                               according the CTM.
  1671. *
  1672. *   SYNOPSIS
  1673. *    error = MWLMeshPolygonVertexAdd( meshhandle,vertex )
  1674. *                                     D1          A0
  1675. *
  1676. *    ULONG MWLMeshPolygonAdd
  1677. *         ( ULONG,TOCLVertex * );
  1678. *
  1679. *   FUNCTION
  1680. *    A new vertex will be added to the polygon. A copy of the contents passed
  1681. *    by the vertex pointer will be made.
  1682. * 
  1683. *   INPUTS
  1684. *     meshhandle   - A valid handle of a mesh.
  1685. *    vertex       - Pointer to a vertex structure which contains the coordinates
  1686. *                   of the new vertex.
  1687. *    
  1688. *   RESULT
  1689. *     error - RCNOERROR    if all went well.
  1690. *            RCNOMESH     if the handle is not valid.
  1691. *            RCNOMEMORY   if there is not enough memory. 
  1692. *            RCNOPOLYGON  if there is no polygon to work with.
  1693. * 
  1694. *   EXAMPLE
  1695. *    error = MWLMeshPolygonVertexAdd(meshhandle,&myvertex);
  1696. *
  1697. *   NOTES
  1698. *    Vertices have to be added in counterclock wise direction.
  1699. *
  1700. *          v3
  1701. *         / |
  1702. *        /  |
  1703. *       /   |
  1704. *      /    |
  1705. *     /     |
  1706. *    v1--->v2
  1707. *
  1708. *
  1709. *   BUGS
  1710. * 
  1711. *   SEE ALSO
  1712. *     MWLMeshPolygonAdd()
  1713. * 
  1714. ******************************************************************************
  1715. *
  1716. */
  1717. ULONG __saveds ASM MWLMeshPolygonVertexAdd(register __d1 ULONG meshhandle,
  1718.                                                 register __a0 TOCLVertex *vertex) {
  1719.                                 
  1720.     TOCLMesh                    *mesh=NULL;
  1721.     TOCLVertexNode                *ver=NULL;
  1722.     TOCLPolygonsVerticesNode    *plv=NULL;
  1723.     TOCLPolygonNode            *pln=NULL;
  1724.     TOCLVertex                    *mvertex=NULL;
  1725.       
  1726.     // make a copy of vertex, a0 is a scratch register
  1727.     mvertex=vertex;
  1728.     
  1729.     mesh=(TOCLMesh *) meshhandle;
  1730.     if (mesh==NULL) return(RCNOMESH);
  1731.  
  1732.     if(mesh->polygons.lastNode==NULL) return(RCNOPOLYGON); /* There is no polygon to work with */
  1733.  
  1734.     /*
  1735.     ** Add a new vertice to the internal vertice list
  1736.     */
  1737.     ver = addVertex(mesh,(*mvertex));
  1738.     if (ver==NULL) {
  1739.         return(RCNOMEMORY);
  1740.     }
  1741.     
  1742.     /*
  1743.     ** Add a new polygon vertex node to the polygon list its last element
  1744.     */
  1745.     plv = AllocPooled(mesh->polygonverticespool,sizeof(TOCLPolygonsVerticesNode));
  1746.     if (plv==NULL) {
  1747.         return(RCNOMEMORY);
  1748.     }
  1749.         
  1750.     plv->vertexNode=ver;
  1751.     plv->next=NULL;
  1752.  
  1753.     pln=mesh->polygons.lastNode;
  1754.      
  1755.     if(pln->firstNode!=NULL) {   /* Check if this is the first vertex to insert or not */
  1756.         pln->lastNode->next=plv;
  1757.         pln->lastNode=plv;
  1758.     }
  1759.     else {
  1760.         pln->lastNode=plv;
  1761.         pln->firstNode=plv;
  1762.     }
  1763.     
  1764.     /*
  1765.     ** Increment the number of vertices counter of the polygon
  1766.     */
  1767.     pln->numberOfVertices++;
  1768.         
  1769.     return(RCNOERROR);
  1770. }
  1771.  
  1772. /****** meshwriter.library/MWLMeshTriangleAdd ******************************************
  1773. * 
  1774. *   NAME    
  1775. *     MWLMeshTriangleAdd -- Add a new triangle to the mesh according the CTM.
  1776. *
  1777. *   SYNOPSIS
  1778. *    error = MWLMeshTriangleAdd( meshhandle,materialhandle,vertex1,vertex2,vertex3 )
  1779. *                                D1         D2              A0       A1      A2
  1780. *
  1781. *    ULONG MWLMeshTriangleAdd
  1782. *         ( ULONG,ULONG,TOCLVertex *,TOCLVertex *,TOCLVertex * );
  1783. *
  1784. *   FUNCTION
  1785. *    A new triangle will be added to the mesh.
  1786. *    This means a new polygon with 3 vertices.
  1787. *    A copy of the contents passed by the vertex pointers will be made.
  1788. * 
  1789. *   INPUTS
  1790. *     meshhandle     - A valid handle of a mesh.
  1791. *    materialhandle - A valid handle of a material or 0 if you wont
  1792. *                     assign a material to this polygon now.
  1793. *    vertex1        - Pointer to the first vertex structure.
  1794. *    vertex2        - Pointer to the second vertex structure.
  1795. *    vertex3        - Pointer to the third vertex structure.
  1796. *    
  1797. *   RESULT
  1798. *     error - RCNOERROR    if all went well.
  1799. *            RCNOMESH     if the handle is not valid.
  1800. *            RCNOMATERIAL if the handle is not valid.
  1801. *            RCNOMEMORY   if there is not enough memory. 
  1802. * 
  1803. *   EXAMPLE
  1804. *    error = MWLMeshTriangleAdd(meshhandle,materialhandle,&v1,&v2,&v3);
  1805. *
  1806. *   NOTES
  1807. *    Vertices have to be added in counterclock wise direction.
  1808. *
  1809. *          v3
  1810. *         / |
  1811. *        /  |
  1812. *       /   |
  1813. *      /    |
  1814. *     /     |
  1815. *    v1--->v2
  1816. *
  1817. *   BUGS
  1818. * 
  1819. *   SEE ALSO
  1820. *     MWLMeshPolygonMaterialSet()
  1821. * 
  1822. ******************************************************************************
  1823. *
  1824. */
  1825. ULONG __saveds ASM MWLMeshTriangleAdd(register __d1 ULONG meshhandle,
  1826.                                         register __d2 ULONG materialhandle,
  1827.                                         register __a0 TOCLVertex *vertex1,
  1828.                                         register __a1 TOCLVertex *vertex2,
  1829.                                         register __a2 TOCLVertex *vertex3) {
  1830.  
  1831.     TOCLMesh                    *mesh=NULL;
  1832.     TOCLMaterialNode            *mat=NULL;
  1833.     TOCLPolygonNode            *pln=NULL;
  1834.     TOCLVertexNode                *ver1=NULL,*ver2=NULL,*ver3=NULL;
  1835.     TOCLPolygonsVerticesNode    *plv1=NULL,*plv2=NULL;
  1836.     TOCLVertex                    *mvertex1=NULL,*mvertex2=NULL,*mvertex3=NULL;
  1837.     
  1838.     // make a copy of vertex1 to 3, a0 and a1 are a scratch registers
  1839.     mvertex1=vertex1;
  1840.     mvertex2=vertex2;
  1841.     mvertex3=vertex3;
  1842.  
  1843.     mesh=(TOCLMesh *) meshhandle;
  1844.     if (mesh==NULL) return(RCNOMESH);
  1845.  
  1846.     mat=getMaterialNode(mesh,materialhandle);
  1847.     if(materialhandle!=0 && mat==NULL) return(RCNOMATERIAL);
  1848.  
  1849.     /*
  1850.     ** Create a new polygon, add it to the internal list
  1851.     */
  1852.     pln = AllocPooled(mesh->polygonpool,sizeof(TOCLPolygonNode));
  1853.     if (pln==NULL) {
  1854.         return(RCNOMEMORY);
  1855.     }
  1856.         
  1857.     pln->numberOfVertices=0;
  1858.     pln->firstNode=NULL;
  1859.     pln->lastNode=NULL;
  1860.     pln->next=NULL;
  1861.     pln->materialNode=mat;
  1862.         
  1863.     if(mesh->polygons.firstNode!=NULL) {   /* Check if this is the first polygon to insert or not */
  1864.         mesh->polygons.lastNode->next=pln;
  1865.         mesh->polygons.lastNode=pln;
  1866.     }
  1867.     else {
  1868.         mesh->polygons.lastNode=pln;
  1869.         mesh->polygons.firstNode=pln;
  1870.     }
  1871.  
  1872.     /*
  1873.     ** Increment the polygon counter
  1874.     */
  1875.     mesh->polygons.numberOfPolygons++;
  1876.  
  1877.     /*
  1878.     ** Add the 3 new vertices to the internal vertice list,
  1879.     ** and add the number of vertices counter of the polygon
  1880.     */
  1881.     ver1 = addVertex(mesh,(*mvertex1));
  1882.     if (ver1==NULL) return(RCNOMEMORY);
  1883.     pln->numberOfVertices++;
  1884.     ver2 = addVertex(mesh,(*mvertex2));
  1885.     if (ver2==NULL) return(RCNOMEMORY);
  1886.     pln->numberOfVertices++;
  1887.     ver3 = addVertex(mesh,(*mvertex3));
  1888.     if (ver3==NULL) return(RCNOMEMORY);
  1889.     pln->numberOfVertices++;
  1890.  
  1891.     /*
  1892.     ** Add the 3 new polygon vertices node to the polygon list its last element
  1893.     */
  1894.     plv1 = AllocPooled(mesh->polygonverticespool,sizeof(TOCLPolygonsVerticesNode));
  1895.     if (plv1==NULL) return(RCNOMEMORY);
  1896.     
  1897.     plv1->vertexNode=ver3;
  1898.     plv1->next=NULL;
  1899.  
  1900.     plv2 = AllocPooled(mesh->polygonverticespool,sizeof(TOCLPolygonsVerticesNode));
  1901.     if (plv2==NULL) return(RCNOMEMORY);
  1902.     
  1903.     plv2->vertexNode=ver2;
  1904.     plv2->next=plv1;
  1905.  
  1906.     plv1 = AllocPooled(mesh->polygonverticespool,sizeof(TOCLPolygonsVerticesNode));
  1907.     if (plv1==NULL) return(RCNOMEMORY);        
  1908.     
  1909.     plv1->vertexNode=ver1;
  1910.     plv1->next=plv2;
  1911.  
  1912.  
  1913.     pln=mesh->polygons.lastNode;
  1914.      
  1915.     if(pln->firstNode!=NULL) {   /* Check if this is the first vertex to insert or not */
  1916.         pln->lastNode->next=plv1;
  1917.         pln->lastNode=plv1;
  1918.     }
  1919.     else {
  1920.         pln->lastNode=plv1;
  1921.         pln->firstNode=plv1;
  1922.     }
  1923.     
  1924.     return(RCNOERROR);
  1925. }
  1926.  
  1927. /****** meshwriter.library/MWLMeshNumberOfMaterialsGet ******************************************
  1928. * 
  1929. *   NAME    
  1930. *     MWLMeshNumberOfMaterialsGet -- Get the number of materials in a mesh.
  1931. * 
  1932. *   SYNOPSIS
  1933. *    number = MWLMeshNumberOfMaterialsGet( meshhandle )
  1934. *                                          D1
  1935. *
  1936. *    ULONG MWLMeshNumberOfMaterialsGet
  1937. *         ( ULONG )
  1938. *
  1939. *   FUNCTION
  1940. *    The current number of materials found in the mesh will be returned.
  1941. * 
  1942. *   INPUTS
  1943. *     meshhandle      - A valid handle of a mesh.
  1944. *    
  1945. *   RESULT
  1946. *     number - Number of materials, 0 if any or no valid mesh.
  1947. *
  1948. *   EXAMPLE
  1949. *    number = MWLMeshNumberOfMaterialsGet(meshhandle);
  1950. *
  1951. *   NOTES
  1952. *
  1953. *   BUGS
  1954. * 
  1955. *   SEE ALSO
  1956. *     MWLMeshNumberOfPolygonsGet(),MWLMeshNumberOfVerticesGet()
  1957. * 
  1958. ******************************************************************************
  1959. *
  1960. */
  1961. ULONG __saveds ASM MWLMeshNumberOfMaterialsGet(register __d1 ULONG meshhandle) {
  1962.     TOCLMesh *mesh=NULL;
  1963.     
  1964.     mesh = (TOCLMesh *) meshhandle;
  1965.     if(mesh==NULL) return(0);
  1966.     
  1967.     return(mesh->materials.numberOfMaterials);
  1968. }
  1969.  
  1970. /****** meshwriter.library/MWLMeshNumberOfPolygonsGet ******************************************
  1971. * 
  1972. *   NAME    
  1973. *     MWLMeshNumberOfPolygonsGet -- Get the number of polygons in a mesh.
  1974. * 
  1975. *   SYNOPSIS
  1976. *    number = MWLMeshNumberOfPolygonsGet( meshhandle )
  1977. *                                         D1
  1978. *
  1979. *    ULONG MWLMeshNumberOfPolygonsGet
  1980. *         ( ULONG )
  1981. *
  1982. *   FUNCTION
  1983. *    The current number of polygons found in the mesh will be returned.
  1984. * 
  1985. *   INPUTS
  1986. *     meshhandle      - A valid handle of a mesh.
  1987. *    
  1988. *   RESULT
  1989. *     number - Number of polygons, 0 if any or no valid mesh.
  1990. *
  1991. *   EXAMPLE
  1992. *    number = MWLMeshNumberOfPolygonsGet(meshhandle);
  1993. *
  1994. *   NOTES
  1995. *
  1996. *   BUGS
  1997. * 
  1998. *   SEE ALSO
  1999. *     MWLMeshNumberOfMaterialsGet(),MWLMeshNumberOfVerticesGet()
  2000. * 
  2001. ******************************************************************************
  2002. *
  2003. */
  2004. ULONG __saveds ASM MWLMeshNumberOfPolygonsGet(register __d1 ULONG meshhandle) {
  2005.     TOCLMesh *mesh=NULL;
  2006.     
  2007.     mesh = (TOCLMesh *) meshhandle;
  2008.     if(mesh==NULL) return(0);
  2009.     
  2010.     return(mesh->polygons.numberOfPolygons);
  2011. }
  2012.  
  2013. /****** meshwriter.library/MWLMeshNumberOfVerticesGet ******************************************
  2014. * 
  2015. *   NAME    
  2016. *     MWLMeshNumberOfVerticesGet -- Get the number of vertices in a mesh.
  2017. * 
  2018. *   SYNOPSIS
  2019. *    number = MWLMeshNumberOfVerticesGet( meshhandle )
  2020. *                                         D1
  2021. *
  2022. *    ULONG MWLMeshNumberOfVerticesGet
  2023. *         ( ULONG )
  2024. *
  2025. *   FUNCTION
  2026. *    The current number of vertices found in the mesh will be returned.
  2027. * 
  2028. *   INPUTS
  2029. *     meshhandle      - A valid handle of a mesh.
  2030. *    
  2031. *   RESULT
  2032. *     number - Number of vertices, 0 if any or no valid mesh.
  2033. *
  2034. *   EXAMPLE
  2035. *    number = MWLMeshNumberOfVerticesGet(meshhandle);
  2036. *
  2037. *   NOTES
  2038. *
  2039. *   BUGS
  2040. * 
  2041. *   SEE ALSO
  2042. *     MWLMeshNumberOfMaterialsGet(),MWLMeshNumberOfPolygonsGet()
  2043. * 
  2044. ******************************************************************************
  2045. *
  2046. */
  2047. ULONG __saveds ASM MWLMeshNumberOfVerticesGet(register __d1 ULONG meshhandle) {
  2048.     TOCLMesh *mesh=NULL;
  2049.     
  2050.     mesh = (TOCLMesh *) meshhandle;
  2051.     if(mesh==NULL) return(0);
  2052.     
  2053.     return(mesh->vertices.numberOfVertices);
  2054. }
  2055.  
  2056. /****** meshwriter.library/MWLMeshCameraLightDefaultSet ******************************************
  2057. * 
  2058. *   NAME    
  2059. *     MWLMeshCameraLightDefaultSet -- Set the camera and light to defaults.
  2060. * 
  2061. *   SYNOPSIS
  2062. *    error = MWLMeshCameraLightDefaultSet( meshhandle )
  2063. *                                          D1
  2064. *
  2065. *    ULONG MWLMeshCameraLightDefaultSet
  2066. *         ( ULONG )
  2067. *
  2068. *   FUNCTION
  2069. *    This function sets the camera and light properties as follows :
  2070. *    Camera looks to the center of the mesh and is positioned to view the whole mesh.
  2071. *    Light is positioned at the same point than the camera and gets a white color.
  2072. * 
  2073. *   INPUTS
  2074. *     meshhandle      - A valid handle of a mesh.
  2075. *    
  2076. *   RESULT
  2077. *     error - RCNOERROR    if all went well.
  2078. *            RCNOMESH     if the handle is not valid.
  2079. *
  2080. *   EXAMPLE
  2081. *    error= MWLMeshCameraLightDefaultSet(meshhandle);
  2082. *
  2083. *   NOTES
  2084. *    Camera and light will be used by some file formats only,
  2085. *    and for 2D or display functions.
  2086. *
  2087. *    If no values are set, this function will be called internally before
  2088. *    using functions which need a camera or a light source.
  2089. *
  2090. *   BUGS
  2091. * 
  2092. *   SEE ALSO
  2093. *     MWLMeshCameraPositionSet(),MWLMeshCameraLookAtSet(),
  2094. *    MWLMeshLightPositionSet(),MWLMeshLightColorSet()
  2095. * 
  2096. ******************************************************************************
  2097. *
  2098. */
  2099. ULONG __saveds ASM MWLMeshCameraLightDefaultSet(register __d1 ULONG meshhandle) {
  2100.     TOCLMesh *mesh=NULL;
  2101.   
  2102.     mesh=(TOCLMesh *) meshhandle;
  2103.     if(mesh==NULL) return(RCNOMESH);
  2104.     
  2105.     setCameraLight(mesh);
  2106.     
  2107.     return(RCNOERROR);
  2108. }
  2109.  
  2110. /****** meshwriter.library/MWLMeshCameraPositionSet ******************************************
  2111. * 
  2112. *   NAME    
  2113. *     MWLMeshCameraPositionSet -- Set the camera position.
  2114. * 
  2115. *   SYNOPSIS
  2116. *    error = MWLMeshCameraPositionSet( meshhandle,position )
  2117. *                                      D1          A0
  2118. *
  2119. *    ULONG MWLMeshCameraPositionSet
  2120. *         ( ULONG,TOCLVertex * );
  2121. *
  2122. *   FUNCTION
  2123. *    The position of the camera will be set to the values passed by the
  2124. *    vertex structure.
  2125. * 
  2126. *   INPUTS
  2127. *     meshhandle      - A valid handle of a mesh.
  2128. *    position        - Pointer to a vertex structure containing the position information.
  2129. *    
  2130. *   RESULT
  2131. *     error - RCNOERROR    if all went well.
  2132. *`            RCNOMESH     if the handle is not valid.
  2133. *
  2134. *   EXAMPLE
  2135. *    error = MWLMeshCameraPositionSet(meshhandle,&myvertex);
  2136. *
  2137. *   NOTES
  2138. *    The camera will be used by some file formats only,
  2139. *    and for 2D or display functions.
  2140. *
  2141. *   BUGS
  2142. * 
  2143. *   SEE ALSO
  2144. *     MWLMeshCameraPositionGet(),MWLMeshCameraLookAtSet(),
  2145. *    MWLMeshCameraLookAtGet()
  2146. * 
  2147. ******************************************************************************
  2148. *
  2149. */
  2150. ULONG __saveds ASM MWLMeshCameraPositionSet(register __d1 ULONG meshhandle,
  2151.                                                 register __a0 TOCLVertex *position) {
  2152.     TOCLMesh        *mesh=NULL;
  2153.     TOCLVertex        *mposition=NULL;
  2154.     
  2155.     // make a copy of position, a0 is a scratch register
  2156.     mposition=position;
  2157.   
  2158.     mesh=(TOCLMesh *) meshhandle;
  2159.     if(mesh==NULL) return(RCNOMESH);
  2160.     
  2161.     mesh->camera.position=(*mposition);
  2162.     
  2163.     return(RCNOERROR);
  2164. }
  2165.  
  2166. /****** meshwriter.library/MWLMeshCameraPositionGet ******************************************
  2167. * 
  2168. *   NAME    
  2169. *     MWLMeshCameraPositionGet -- Get the position of the camera.
  2170. * 
  2171. *   SYNOPSIS
  2172. *    error = MWLMeshCameraPositionGet( meshhandle,position )
  2173. *                                      D1          A0
  2174. *
  2175. *    ULONG MWLMeshCameraPositionGet
  2176. *         ( ULONG,TOCLVertex * );
  2177. *
  2178. *   FUNCTION
  2179. *    The position of the camera will be written in the passed vertex structure.
  2180. * 
  2181. *   INPUTS
  2182. *     meshhandle      - A valid handle of a mesh.
  2183. *    position        - Pointer to a vertex structure which will contain
  2184. *                      the position information.
  2185. *    
  2186. *   RESULT
  2187. *     error - RCNOERROR    if all went well.
  2188. *            RCNOMESH     if the handle is not valid.
  2189. *
  2190. *   EXAMPLE
  2191. *    error = MWLMeshCameraPositionGet(meshhandle,&myvertex);
  2192. *
  2193. *   NOTES
  2194. *    The camera will be used by some file formats only,
  2195. *    and for 2D or display functions.
  2196. *
  2197. *   BUGS
  2198. * 
  2199. *   SEE ALSO
  2200. *     MWLMeshCameraPositionSet(),MWLMeshCameraLookAtSet()
  2201. *    MWLMeshCameraLookAtGet()
  2202. * 
  2203. ******************************************************************************
  2204. *
  2205. */
  2206. ULONG __saveds ASM MWLMeshCameraPositionGet(register __d1 ULONG meshhandle,
  2207.                                                 register __a0 TOCLVertex *position) {
  2208.     TOCLMesh        *mesh=NULL;
  2209.     TOCLVertex    *mposition=NULL;
  2210.     
  2211.     // make a copy of position, a0 is a scratch register
  2212.     mposition=position;
  2213.  
  2214.     mesh = (TOCLMesh *) meshhandle;
  2215.     if(mesh==NULL) return(RCNOMESH);
  2216.  
  2217.     (*mposition)=mesh->camera.position;
  2218.     
  2219.     return(RCNOERROR);
  2220. }
  2221.  
  2222. /****** meshwriter.library/MWLMeshCameraLookAtSet ******************************************
  2223. * 
  2224. *   NAME    
  2225. *     MWLMeshCameraLookAtSet -- Set the camera its view point.
  2226. * 
  2227. *   SYNOPSIS
  2228. *    error = MWLMeshCameraLookAtSet( meshhandle,lookat )
  2229. *                                    D1          A0
  2230. *
  2231. *    ULONG MWLMeshCameraLookAtSet
  2232. *         ( ULONG,TOCLVertex * );
  2233. *
  2234. *   FUNCTION
  2235. *    The view point of the camera will be set to the values passed by the
  2236. *    vertex structure.
  2237. * 
  2238. *   INPUTS
  2239. *     meshhandle      - A valid handle of a mesh.
  2240. *    lookat          - Pointer to a vertex structure containing the position information.
  2241. *    
  2242. *   RESULT
  2243. *     error - RCNOERROR    if all went well.
  2244. *            RCNOMESH     if the handle is not valid.
  2245. *
  2246. *   EXAMPLE
  2247. *    error = MWLMeshCameraLookAtSet(meshhandle,&myvertex);
  2248. *
  2249. *   NOTES
  2250. *    The camera will be used by some file formats only,
  2251. *    and for 2D or display functions.
  2252. *
  2253. *   BUGS
  2254. * 
  2255. *   SEE ALSO
  2256. *     MWLMeshCameraLookAtGet(),MWLMeshCameraPositionSet()
  2257. *    MWLMeshCameraPositionSet()
  2258. * 
  2259. ******************************************************************************
  2260. *
  2261. */
  2262. ULONG __saveds ASM MWLMeshCameraLookAtSet(register __d1 ULONG meshhandle,
  2263.                                             register __a0 TOCLVertex *lookat) {
  2264.     TOCLMesh        *mesh=NULL;
  2265.     TOCLVertex        *mlookat=NULL;
  2266.  
  2267.     // make a copy of lookat, a0 is a scratch register
  2268.     mlookat=lookat;
  2269.  
  2270.     mesh=(TOCLMesh *) meshhandle;
  2271.     if(mesh==NULL) return(RCNOMESH);
  2272.     
  2273.     mesh->camera.lookat=(*mlookat);
  2274.     
  2275.     return(RCNOERROR);
  2276. }
  2277.  
  2278. /****** meshwriter.library/MWLMeshCameraLookAtGet ******************************************
  2279. * 
  2280. *   NAME    
  2281. *     MWLMeshCameraLookAtGet -- Get the view point of the camera.
  2282. * 
  2283. *   SYNOPSIS
  2284. *    error = MWLMeshCameraLookAtGet( meshhandle,lookat )
  2285. *                                    D1          A0
  2286. *
  2287. *    ULONG MWLMeshCameraLookAtGet
  2288. *         ( ULONG,TOCLVertex * );
  2289. *
  2290. *   FUNCTION
  2291. *    The view point of the camera will be written in the passed vertex structure.
  2292. * 
  2293. *   INPUTS
  2294. *     meshhandle      - A valid handle of a mesh.
  2295. *    lookat          - Pointer to a vertex structure which will contain
  2296. *                      the position information.
  2297. *    
  2298. *   RESULT
  2299. *     error - RCNOERROR    if all went well.
  2300. *            RCNOMESH     if the handle is not valid.
  2301. *
  2302. *   EXAMPLE
  2303. *    error = MWLMeshCameraLookAtGet(meshhandle,&myvertex);
  2304. *
  2305. *   NOTES
  2306. *    The camera will be used by some file formats only,
  2307. *    and for 2D or display functions.
  2308. *
  2309. *   BUGS
  2310. * 
  2311. *   SEE ALSO
  2312. *     MWLMeshCameraLookAtSet(),MWLMeshCameraPositionSet()
  2313. *    MWLMeshCameraPositionGet()
  2314. * 
  2315. ******************************************************************************
  2316. *
  2317. */
  2318. ULONG __saveds ASM MWLMeshCameraLookAtGet(register __d1 ULONG meshhandle,
  2319.                                             register __a0 TOCLVertex *lookat) {
  2320.     TOCLMesh        *mesh=NULL;
  2321.     TOCLVertex        *mlookat=NULL;
  2322.     
  2323.     // make a copy of lookat, a0 is a scratch register
  2324.     mlookat=lookat;
  2325.   
  2326.     mesh=(TOCLMesh *) meshhandle;
  2327.     if(mesh==NULL) return(RCNOMESH);
  2328.  
  2329.     (*mlookat)=mesh->camera.lookat;
  2330.     
  2331.     return(RCNOERROR);
  2332. }
  2333.  
  2334. /****** meshwriter.library/MWLMeshLightPositionSet ******************************************
  2335. * 
  2336. *   NAME    
  2337. *     MWLMeshLightPositionSet -- Set the light source its position.
  2338. * 
  2339. *   SYNOPSIS
  2340. *    error = MWLMeshLightPositionSet( meshhandle,position )
  2341. *                                     D1          A0
  2342. *
  2343. *    ULONG MWLMeshLightPositionSet
  2344. *         ( ULONG,TOCLVertex * );
  2345. *
  2346. *   FUNCTION
  2347. *    The position of the light source will be set to the values passed by the
  2348. *    vertex structure.
  2349. * 
  2350. *   INPUTS
  2351. *     meshhandle      - A valid handle of a mesh.
  2352. *    position        - Pointer to a vertex structure containing the position information.
  2353. *    
  2354. *   RESULT
  2355. *     error - RCNOERROR    if all went well.
  2356. *            RCNOMESH     if the handle is not valid.
  2357. *
  2358. *   EXAMPLE
  2359. *    error = MWLMeshLightPositionSet(meshhandle,&myvertex);
  2360. *
  2361. *   NOTES
  2362. *    The light will be used by some file formats only,
  2363. *    and for 2D or display functions.
  2364. *
  2365. *   BUGS
  2366. * 
  2367. *   SEE ALSO
  2368. *     MWLMeshLightPositionGet(),MWLMeshLightColorSet()
  2369. *    MWLMeshLightColorGet()
  2370. * 
  2371. ******************************************************************************
  2372. *
  2373. */
  2374. ULONG __saveds ASM MWLMeshLightPositionSet(register __d1 ULONG meshhandle,
  2375.                                                 register __a0 TOCLVertex *position) {
  2376.     TOCLMesh        *mesh=NULL;
  2377.     TOCLVertex        *mposition=NULL;
  2378.  
  2379.     // make a copy of position, a0 is a scratch register
  2380.     mposition=position;
  2381.  
  2382.     mesh=(TOCLMesh *) meshhandle;
  2383.     if(mesh==NULL) return(RCNOMESH);
  2384.     
  2385.     mesh->light.position=(*mposition);
  2386.     
  2387.     return(RCNOERROR);
  2388. }
  2389.  
  2390. /****** meshwriter.library/MWLMeshLightPositionGet ******************************************
  2391. * 
  2392. *   NAME    
  2393. *     MWLMeshLightPositionGet -- Get the position of the light source.
  2394. * 
  2395. *   SYNOPSIS
  2396. *    error = MWLMeshLightPositionGet( meshhandle,position )
  2397. *                                     D1          A0
  2398. *
  2399. *    ULONG MWLMeshLightPositionGet
  2400. *         ( ULONG,TOCLVertex * );
  2401. *
  2402. *   FUNCTION
  2403. *    The position of the light source will be written in the passed vertex structure.
  2404. * 
  2405. *   INPUTS
  2406. *     meshhandle      - A valid handle of a mesh.
  2407. *    position        - Pointer to a vertex structure which will contain
  2408. *                      the position information.
  2409. *    
  2410. *   RESULT
  2411. *     error - RCNOERROR    if all went well.
  2412. *            RCNOMESH     if the handle is not valid.
  2413. *
  2414. *   EXAMPLE
  2415. *    error = MWLMeshLightPositionGet(meshhandle,&myvertex);
  2416. *
  2417. *   NOTES
  2418. *    The light will be used by some file formats only,
  2419. *    and for 2D or display functions.
  2420. *
  2421. *   BUGS
  2422. * 
  2423. *   SEE ALSO
  2424. *     MWLMeshLightPositionSet(),MWLMeshLightColorSet()
  2425. *    MWLMeshLightColorGet()
  2426. * 
  2427. ******************************************************************************
  2428. *
  2429. */
  2430. ULONG __saveds ASM MWLMeshLightPositionGet(register __d1 ULONG meshhandle,
  2431.                                                 register __a0 TOCLVertex *position) {
  2432.     TOCLMesh        *mesh=NULL;
  2433.     TOCLVertex        *mposition=NULL;
  2434.     
  2435.     // make a copy of position, a0 is a scratch register
  2436.     mposition=position;
  2437.   
  2438.     mesh=(TOCLMesh *) meshhandle;
  2439.     if(mesh==NULL) return(RCNOMESH);
  2440.  
  2441.     (*mposition)=mesh->light.position;
  2442.     
  2443.     return(RCNOERROR);
  2444. }
  2445.  
  2446. /****** meshwriter.library/MWLMeshLightColorSet ******************************************
  2447. * 
  2448. *   NAME    
  2449. *     MWLMeshLightColorSet -- Set the light source its color.
  2450. * 
  2451. *   SYNOPSIS
  2452. *    error = MWLMeshLightColorSet( meshhandle,color )
  2453. *                                  D1          A0
  2454. *
  2455. *    ULONG MWLMeshLightColorSet
  2456. *         ( ULONG,TOCLColor * );
  2457. *
  2458. *   FUNCTION
  2459. *    The color of the light source will be set to the values passed by the
  2460. *    color structure.
  2461. * 
  2462. *   INPUTS
  2463. *     meshhandle      - A valid handle of a mesh.
  2464. *    color           - Pointer to a color structure containing the color information.
  2465. *    
  2466. *   RESULT
  2467. *     error - RCNOERROR    if all went well.
  2468. *            RCNOMESH     if the handle is not valid.
  2469. *
  2470. *   EXAMPLE
  2471. *    error = MWLMeshLightColorSet(meshhandle,&mycolor);
  2472. *
  2473. *   NOTES
  2474. *    The light will be used by some file formats only,
  2475. *    and for 2D or display functions.
  2476. *
  2477. *   BUGS
  2478. * 
  2479. *   SEE ALSO
  2480. *     MWLMeshLightColorGet(),MWLMeshLightPositionSet()
  2481. *    MWLMeshLightPositionGet()
  2482. * 
  2483. ******************************************************************************
  2484. *
  2485. */
  2486. ULONG __saveds ASM MWLMeshLightColorSet(register __d1 ULONG meshhandle,
  2487.                                             register __a0 TOCLColor *color) {
  2488.     TOCLMesh    *mesh=NULL;
  2489.     TOCLColor    *mcolor=NULL;
  2490.     
  2491.     // make a copy of color, a0 is a scratch register
  2492.     mcolor=color;
  2493.   
  2494.     mesh=(TOCLMesh *) meshhandle;
  2495.     if(mesh==NULL) return(RCNOMESH);
  2496.     
  2497.     mesh->light.color=(*mcolor);
  2498.  
  2499.     return(RCNOERROR);
  2500. }
  2501.  
  2502. /****** meshwriter.library/MWLMeshLightColorGet ******************************************
  2503. * 
  2504. *   NAME    
  2505. *     MWLMeshLightColorGet -- Get the color of the light source.
  2506. * 
  2507. *   SYNOPSIS
  2508. *    error = MWLMeshLightColorGet( meshhandle,color )
  2509. *                                  D1          A0
  2510. *
  2511. *    ULONG MWLMeshLightColorGet
  2512. *         ( ULONG,TOCLColor * );
  2513. *
  2514. *   FUNCTION
  2515. *    The color of the light source will be written in the passed color structure.
  2516. * 
  2517. *   INPUTS
  2518. *     meshhandle      - A valid handle of a mesh.
  2519. *    color           - Pointer to a color structure which will contain
  2520. *                      the color information.
  2521. *    
  2522. *   RESULT
  2523. *     error - RCNOERROR    if all went well.
  2524. *            RCNOMESH     if the handle is not valid.
  2525. *
  2526. *   EXAMPLE
  2527. *    error = MWLMeshLightColorGet(meshhandle,&mycolor);
  2528. *
  2529. *   NOTES
  2530. *    The light will be used by some file formats only,
  2531. *    and for 2D or display functions.
  2532. *
  2533. *   BUGS
  2534. * 
  2535. *   SEE ALSO
  2536. *     MWLMeshLightColorSet(),MWLMeshLightPositionSet()
  2537. *    MWLMeshLightPositionGet()
  2538. * 
  2539. ******************************************************************************
  2540. *
  2541. */
  2542. ULONG __saveds ASM MWLMeshLightColorGet(register __d1 ULONG meshhandle,
  2543.                                             register __a0 TOCLColor *color) {
  2544.     TOCLMesh    *mesh=NULL;
  2545.     TOCLColor    *mcolor=NULL;
  2546.     
  2547.     // make a copy of color, a0 is a scratch register
  2548.     mcolor=color;
  2549.  
  2550.     mesh=(TOCLMesh *) meshhandle;
  2551.     if(mesh==NULL) return(RCNOMESH);
  2552.  
  2553.     (*color)=mesh->light.color;
  2554.     
  2555.     return(RCNOERROR);
  2556. }
  2557.  
  2558. /****** meshwriter.library/MWL3DFileFormatNamesGet ******************************************
  2559. * 
  2560. *   NAME    
  2561. *     MWL3DFileFormatNamesGet -- Get a name list of all supported 3D file formats.
  2562. * 
  2563. *   SYNOPSIS
  2564. *    list = MWL3DFileFormatNamesGet(  )
  2565. *
  2566. *    STRPTR * MWL3DFileFormatNamesGet
  2567. *         (  );
  2568. *
  2569. *   FUNCTION
  2570. *    You will get a pointer to the namelist of all supported 3D file formats.
  2571. *    This strings are READ_ONLY and only valid as long as the library is opened.
  2572. *
  2573. *    The list is sorted alphabetically.
  2574. *
  2575. *    The resulting pointer can directly be used to fill up cycle or list gadgets
  2576. *    for example.
  2577. * 
  2578. *   INPUTS
  2579. *    
  2580. *   RESULT
  2581. *     list - A NULL terminated array of string pointers. Or NULL if no
  2582. *           files are supported.
  2583. *
  2584. *   EXAMPLE
  2585. *    list = MWL3DFileFormatNamesGet();
  2586. *
  2587. *   NOTES
  2588. *
  2589. *   BUGS
  2590. * 
  2591. *   SEE ALSO
  2592. *     MWL3DFileFormatIDGet(),MWL3DFileFormatExtensionGet()
  2593. *    MWL3DFileFormatNumberOfGet()
  2594. * 
  2595. ******************************************************************************
  2596. *
  2597. */
  2598. STRPTR * __saveds ASM MWL3DFileFormatNamesGet() {
  2599.     if(c3dFFNames[0]!=NULL) return(c3dFFNames);
  2600.     return(NULL);
  2601. }
  2602.  
  2603. /****** meshwriter.library/MWL3DFileFormatIDGet ******************************************
  2604. * 
  2605. *   NAME    
  2606. *     MWL3DFileFormatIDGet -- Get the ID of a specific 3D file format.
  2607. * 
  2608. *   SYNOPSIS
  2609. *    id = MWL3DFileFormatIDGet( ffname )
  2610. *                                D1
  2611. *
  2612. *    ULONG MWL3DFileFormatIDGet
  2613. *         ( STRPTR );
  2614. *
  2615. *   FUNCTION
  2616. *    You will get the ID of the 3D file format of which you passed its name.
  2617. * 
  2618. *   INPUTS
  2619. *    ffname - Name of the format you search the ID for.
  2620. *    
  2621. *   RESULT
  2622. *     id - The ID of the 3D file format or 0 if not found/supported.
  2623. *
  2624. *   EXAMPLE
  2625. *    id = MWL3DFileFormatIDGet("Lightwave");
  2626. *
  2627. *   NOTES
  2628. *    Even if the values of the IDs wont change in future versions, it is
  2629. *    recomended to show the list of all names to the user and let him choose
  2630. *    the format. With the help of this function you will get the correct
  2631. *    ID which is needed for further function calls.
  2632. *
  2633. *   BUGS
  2634. * 
  2635. *   SEE ALSO
  2636. *     MWL3DFileFormatNamesGet(),MWL3DFileFormatExtensionGet()
  2637. *    MWL3DFileFormatNumberOfGet()
  2638. * 
  2639. ******************************************************************************
  2640. *
  2641. */
  2642. ULONG __saveds ASM MWL3DFileFormatIDGet(register __d1 STRPTR ffname) {
  2643.     ULONG i;
  2644.         
  2645.     i=0;
  2646.     while(strcmp(c3dFFNames[i],ffname) && c3dFFNames[i]!=NULL) {i++};
  2647.     
  2648.     // check if we got it or not
  2649.     if(!strcmp(c3dFFNames[i],ffname)) return(c3dFFIDs[i]);
  2650.     else return(0);
  2651. }
  2652.  
  2653. /****** meshwriter.library/MWL3DFileFormatExtensionGet ******************************************
  2654. * 
  2655. *   NAME    
  2656. *     MWL3DFileFormatExtensionGet -- Get the file extension of a specific 3D file format.
  2657. * 
  2658. *   SYNOPSIS
  2659. *    ext = MWL3DFileFormatExtensionGet( ffid )
  2660. *                                       D1
  2661. *
  2662. *    STRPTR MWL3DFileFormatExtensionGet
  2663. *         ( ULONG );
  2664. *
  2665. *   FUNCTION
  2666. *    You will get a pointer to the extension of the specified 3D file format.
  2667. *    This strings are READ_ONLY and only valid as long as the library is opened.
  2668. * 
  2669. *   INPUTS
  2670. *    ffid - ID of the file format you search the extension for.
  2671. *    
  2672. *   RESULT
  2673. *     ext - Pointer to the file extension string or NULL if the format is unknown.
  2674. *
  2675. *   EXAMPLE
  2676. *    ext = MWL3DFileFormatExtensionGet(id);
  2677. *
  2678. *   NOTES
  2679. *    This extensions are proposals of the format creators, but you are free
  2680. *    to use them.
  2681. *
  2682. *   BUGS
  2683. * 
  2684. *   SEE ALSO
  2685. *     MWL3DFileFormatNamesGet(),MWL3DFileFormatIDGet()
  2686. *    MWL3DFileFormatNumberOfGet()
  2687. * 
  2688. ******************************************************************************
  2689. *
  2690. */
  2691. STRPTR __saveds ASM MWL3DFileFormatExtensionGet(register __d1 ULONG ffid) {
  2692.     ULONG i,mffid;
  2693.         
  2694.     // make a copy of ffid, because d1 is a scratch register
  2695.     mffid=ffid;
  2696.         
  2697.     i=0;
  2698.     while(c3dFFIDs[i]!=mffid && c3dFFIDs[i]!=0) {i++};
  2699.     
  2700.     // check if we got it or not
  2701.     if(c3dFFIDs[i]==mffid) return(c3dFFExtensions[i]);
  2702.     else return(NULL);
  2703. }
  2704.  
  2705. /****** meshwriter.library/MWL3DFileFormatNumberOfGet ******************************************
  2706. * 
  2707. *   NAME    
  2708. *     MWL3DFileFormatNumberOfGet -- Get the number of supported 3D file formats.
  2709. * 
  2710. *   SYNOPSIS
  2711. *    number = MWL3DFileFormatNumberOfGet( )
  2712. *
  2713. *    ULONG MWL3DFileFormatNumberOfGet
  2714. *         ( );
  2715. *
  2716. *   FUNCTION
  2717. *    You will get the number of supported 3D file formats of this library version.
  2718. * 
  2719. *   INPUTS
  2720. *    
  2721. *   RESULT
  2722. *     number - Number of supported file formats or 0 if none.
  2723. *
  2724. *   EXAMPLE
  2725. *    number = MWL3DFileFormatNumberOfGet();
  2726. *
  2727. *   NOTES
  2728. *
  2729. *   BUGS
  2730. * 
  2731. *   SEE ALSO
  2732. *     MWL3DFileFormatNamesGet(),MWL3DFileFormatIDGet()
  2733. *    MWL3DFileFormatNumberExtensionGet()
  2734. * 
  2735. ******************************************************************************
  2736. *
  2737. */
  2738. ULONG __saveds ASM MWL3DFileFormatNumberOfGet() {
  2739.     ULONG  i;
  2740.     STRPTR *sIndex=NULL;
  2741.  
  2742.     i=0;
  2743.     sIndex=c3dFFNames;
  2744.     while (sIndex[i]!=NULL) i++;
  2745.     
  2746.     return(i);
  2747. }
  2748.  
  2749. /****** meshwriter.library/MWLMeshSave3D ******************************************
  2750. * 
  2751. *   NAME    
  2752. *     MWLMeshSave3D -- Saves the mesh as 3D file..
  2753. *
  2754. *   SYNOPSIS
  2755. *    error = MWLMeshSave3D( meshhandle,id,filename,taglist )
  2756. *                           D1         D2 D3        A0
  2757. *
  2758. *    ULONG MWLMeshSave3D
  2759. *         ( ULONG,ULONG,STRPTR,struct TagItem * );
  2760. *
  2761. *   FUNCTION
  2762. *    The mesh, this means vertices, polygons, materials, camera and light will
  2763. *    be saved in the specified 3d file format.
  2764. * 
  2765. *   INPUTS
  2766. *     meshhandle  - A valid handle of a mesh.
  2767. *    id          - A valid 3D file format id, to spedify the output format.
  2768. *    filename    - Name and path of the file.
  2769. *    taglist     - NULL, for future use.
  2770. *    
  2771. *   RESULT
  2772. *    error - RCNOERROR                  if all went well.
  2773. *            RCNOMESH                   if the handle is not valid.
  2774. *            RCUNKNOWNFTYPE             if the id is not known.
  2775. *            RCNOPOLYGON                if there are no polygons to save.
  2776. *            RCCHGBUF                   if an error occured to allocate the save buffer.
  2777. *            RCWRITEDATA                if an error occured while writing data, no more space...
  2778. *            RCVERTEXOVERFLOW           if the format does not support as much vertices.
  2779. *            RCVERTEXINPOLYGONOVERFLOW  if the format does not support as much vertices in a polygon.
  2780. *            IoErr()                    if possible to catch it, you will get its codes.
  2781. *
  2782. *   EXAMPLE
  2783. *    error = MWLMeshSave3D(meshhandle,id,"ram:test",NULL);
  2784. *
  2785. *   NOTES
  2786. *    No file existence tests are made here! Existent files will be overwritten.
  2787. *
  2788. *   BUGS
  2789. * 
  2790. *   SEE ALSO
  2791. *     MWL3DFileFormatIDGet(),MWLMeshSave2D()
  2792. * 
  2793. ******************************************************************************
  2794. *
  2795. */
  2796. ULONG __saveds ASM MWLMeshSave3D(register __d1 ULONG meshhandle,
  2797.                                     register __d2 ULONG id,
  2798.                                     register __d3 STRPTR filename,
  2799.                                     register __a0 struct TagItem *taglist) {
  2800.     TOCLMesh        *mesh;
  2801.     BPTR            filehandle=NULL;
  2802.     ULONG            retcode=RCNOERROR;
  2803.     UBYTE            i;
  2804.     struct TagItem    *mtaglist=NULL;
  2805.     
  2806.     // make a copy of taglist, a0 is a scratch register
  2807.     mtaglist=taglist;
  2808.  
  2809.     mesh = (TOCLMesh *) meshhandle;
  2810.     if(mesh==NULL) return(RCNOMESH);    
  2811.  
  2812.       /*
  2813.       ** If there are no polygons, so leave
  2814.       */
  2815.     if(mesh->polygons.firstNode==NULL) return(RCNOPOLYGON);
  2816.     
  2817.     /*
  2818.     ** Check if the filetype is valid
  2819.     */
  2820.     i=0;
  2821.     while(c3dFFIDs[i]!=id && c3dFFIDs[i]!=0) {i++};
  2822.     if(c3dFFIDs[i]!=id || id==0) return(RCUNKNOWNFTYPE);
  2823.     
  2824.     /*
  2825.     ** If no camera and light position was given, set it to default now
  2826.     */
  2827.     if (!(mesh->camera.position.x &&
  2828.          mesh->camera.position.y &&
  2829.          mesh->camera.position.z &&
  2830.          mesh->camera.lookat.x &&
  2831.          mesh->camera.lookat.y &&
  2832.          mesh->camera.lookat.z &&
  2833.          mesh->light.position.x &&
  2834.          mesh->light.position.y &&
  2835.          mesh->light.position.z)) setCameraLight(mesh);
  2836.  
  2837.     /*
  2838.     ** Open the file 
  2839.     */
  2840.     /* Open the file for text output */
  2841.     if((filehandle=Open(filename,MODE_NEWFILE))==NULL) return(IoErr());
  2842.  
  2843.     /* Change the buffer size of the filehandle to 10k */
  2844.     if (SetVBuf(filehandle,NULL,BUF_FULL,10000)!=DOSFALSE) {
  2845.         Close(filehandle);
  2846.         return(RCCHGBUF);
  2847.     }
  2848.  
  2849.     /*
  2850.     ** Write the mesh
  2851.     */
  2852.     switch(id) {
  2853.         case T3DFRAWA :
  2854.             retcode = write3RAWA(filehandle,mesh);
  2855.             break;
  2856.         case T3DFRAWB :
  2857.             retcode = write3RAWB(filehandle,mesh);
  2858.             break;
  2859.         case T3DFDXF :
  2860.             retcode = write3DXF(filehandle,mesh);
  2861.             break;
  2862.         case T3DFVRML1 :
  2863.             retcode = write3VRML1(filehandle,mesh);
  2864.             break;
  2865.         case T3DFPOV3 :
  2866.             retcode = write3POV3(filehandle,mesh);
  2867.             break;
  2868.         case T3DFTDDD :
  2869.             retcode = write3TDDD(filehandle,mesh);
  2870.             break;
  2871.         case T3DFTDDDH :
  2872.             retcode = write3TDDDH(filehandle,mesh);
  2873.             break;
  2874.         case T3DFREF4 :
  2875.             retcode = write3REF4(filehandle,mesh);
  2876.             break;
  2877.         case T3DFLWOB :
  2878.             retcode = write3LWOB(filehandle,mesh);
  2879.             break;
  2880.         case T3DFGEOA :
  2881.             retcode = write3GEOA(filehandle,mesh);
  2882.             break;
  2883. //        case T3DFREAL :
  2884. //            retcode = write3REAL(filehandle,mesh);
  2885. //            break;
  2886.     }
  2887.     
  2888.     /*
  2889.     ** Close the file
  2890.     */
  2891.     Close(filehandle);
  2892.     
  2893.     return(retcode);
  2894. }
  2895.  
  2896. /****** meshwriter.library/MWL2DFileFormatNamesGet ******************************************
  2897. * 
  2898. *   NAME    
  2899. *     MWL2DFileFormatNamesGet -- Get a name list of all supported 2D file formats.
  2900. * 
  2901. *   SYNOPSIS
  2902. *    list = MWL2DFileFormatNamesGet(  )
  2903. *
  2904. *    STRPTR * MWL2DFileFormatNamesGet
  2905. *         (  );
  2906. *
  2907. *   FUNCTION
  2908. *    You will get a pointer to the namelist of all supported 2D file formats.
  2909. *    This strings are READ_ONLY and only valid as long as the library is opened.
  2910. *
  2911. *    The list is sorted alphabetically.
  2912. *
  2913. *    The resulting pointer can directly be used to fill up cycle or list gadgets
  2914. *    for example.
  2915. * 
  2916. *   INPUTS
  2917. *    
  2918. *   RESULT
  2919. *     list - A NULL terminated array of string pointers. Or NULL if no
  2920. *           files are supported.
  2921. *
  2922. *   EXAMPLE
  2923. *    list = MWL2DFileFormatNamesGet();
  2924. *
  2925. *   NOTES
  2926. *
  2927. *   BUGS
  2928. * 
  2929. *   SEE ALSO
  2930. *     MWL2DFileFormatIDGet(),MWL2DFileFormatExtensionGet()
  2931. *    MWL2DFileFormatNumberOfGet()
  2932. * 
  2933. ******************************************************************************
  2934. *
  2935. */
  2936. STRPTR * __saveds ASM MWL2DFileFormatNamesGet() {
  2937.     if(c2dFFNames[0]!=NULL) return(c2dFFNames);
  2938.     return(NULL);
  2939. }
  2940.  
  2941. /****** meshwriter.library/MWL2DFileFormatIDGet ******************************************
  2942. * 
  2943. *   NAME    
  2944. *     MWL2DFileFormatIDGet -- Get the ID of a specific 2D file format.
  2945. * 
  2946. *   SYNOPSIS
  2947. *    id = MWL2DFileFormatIDGet( ffname )
  2948. *                               D1
  2949. *
  2950. *    ULONG MWL2DFileFormatIDGet
  2951. *         ( STRPTR );
  2952. *
  2953. *   FUNCTION
  2954. *    You will get the ID of the 2D file format of which you passed its name.
  2955. * 
  2956. *   INPUTS
  2957. *    ffname - Name of the format you search the ID for.
  2958. *    
  2959. *   RESULT
  2960. *     id - The ID of the 2D file format or 0 if not found/supported.
  2961. *
  2962. *   EXAMPLE
  2963. *    id = MWL2DFileFormatIDGet("PostScript");
  2964. *
  2965. *   NOTES
  2966. *    Even if the values of the IDs wont change in future versions, it is
  2967. *    recomended to show the list of all names to the user and let him choose
  2968. *    the format. With the help of this function you will get the correct
  2969. *    ID which is needed for further function calls.
  2970. *
  2971. *   BUGS
  2972. * 
  2973. *   SEE ALSO
  2974. *     MWL2DFileFormatNamesGet(),MWL2DFileFormatExtensionGet()
  2975. *    MWL2DFileFormatNumberOfGet()
  2976. * 
  2977. ******************************************************************************
  2978. *
  2979. */
  2980. ULONG __saveds ASM MWL2DFileFormatIDGet(register __d1 STRPTR ffname) {
  2981.     ULONG i;
  2982.     STRPTR mffname=NULL;
  2983.  
  2984.     // make a copy of ffname, d1 is a scratch register
  2985.     mffname=ffname;
  2986.  
  2987.     i=0;
  2988.     while(strcmp(c2dFFNames[i],mffname) && c2dFFNames[i]!=NULL) {i++};
  2989.     
  2990.     // check if we got it or not
  2991.     if(!strcmp(c2dFFNames[i],mffname)) return(c2dFFIDs[i]);
  2992.     else return(0);
  2993. }
  2994.  
  2995. /****** meshwriter.library/MWL2DFileFormatExtensionGet ******************************************
  2996. * 
  2997. *   NAME    
  2998. *     MWL2DFileFormatExtensionGet -- Get the file extension of a specific 2D file format.
  2999. * 
  3000. *   SYNOPSIS
  3001. *    ext = MWL2DFileFormatExtensionGet( ffid )
  3002. *                                       D1
  3003. *
  3004. *    STRPTR MWL2DFileFormatExtensionGet
  3005. *         ( ULONG );
  3006. *
  3007. *   FUNCTION
  3008. *    You will get a pointer to the extension of the specified 2D file format.
  3009. *    This strings are READ_ONLY and only valid as long as the library is opened.
  3010. * 
  3011. *   INPUTS
  3012. *    ffid - ID of the format you search the extension for.
  3013. *    
  3014. *   RESULT
  3015. *     ext - Pointer to the file extension string or NULL if the format is unknown.
  3016. *
  3017. *   EXAMPLE
  3018. *    ext = MWL2DFileFormatExtensionGet(id);
  3019. *
  3020. *   NOTES
  3021. *    This extensions are proposals of the format creators, but you are free
  3022. *    to use them.
  3023. *
  3024. *   BUGS
  3025. * 
  3026. *   SEE ALSO
  3027. *     MWL2DFileFormatNamesGet(),MWL2DFileFormatIDGet()
  3028. *    MWL2DFileFormatNumberOfGet()
  3029. * 
  3030. ******************************************************************************
  3031. *
  3032. */
  3033. STRPTR __saveds ASM MWL2DFileFormatExtensionGet(register __d1 ULONG ffid) {
  3034.     ULONG i,mffid;
  3035.  
  3036.     // make a copy of ffid, d1 is a scratch register
  3037.     mffid=ffid;
  3038.     
  3039.     i=0;
  3040.     while(c2dFFIDs[i]!=mffid && c2dFFIDs[i]!=0) {i++};
  3041.     
  3042.     // check if we got it or not
  3043.     if(c2dFFIDs[i]==mffid) return(c2dFFExtensions[i]);
  3044.     else return(NULL);
  3045. }
  3046.  
  3047. /****** meshwriter.library/MWL2DFileFormatNumberOfGet ******************************************
  3048. * 
  3049. *   NAME    
  3050. *     MWL2DFileFormatNumberOfGet -- Get the number of supported 2D file formats.
  3051. * 
  3052. *   SYNOPSIS
  3053. *    number = MWL2DFileFormatNumberOfGet( )
  3054. *
  3055. *    ULONG MWL2DFileFormatNumberOfGet
  3056. *         ( );
  3057. *
  3058. *   FUNCTION
  3059. *    You will get the number of supported 2D file formats of this library version.
  3060. * 
  3061. *   INPUTS
  3062. *    
  3063. *   RESULT
  3064. *     number - Number of supported file formats or 0 if none.
  3065. *
  3066. *   EXAMPLE
  3067. *    number = MWL2DFileFormatNumberOfGet();
  3068. *
  3069. *   NOTES
  3070. *
  3071. *   BUGS
  3072. * 
  3073. *   SEE ALSO
  3074. *     MWL2DFileFormatNamesGet(),MWL2DFileFormatIDGet()
  3075. *    MWL2DFileFormatNumberExtensionGet()
  3076. * 
  3077. ******************************************************************************
  3078. *
  3079. */
  3080. ULONG __saveds ASM MWL2DFileFormatNumberOfGet() {
  3081.     ULONG  i;
  3082.     STRPTR *sIndex=NULL;
  3083.  
  3084.     i=0;
  3085.     sIndex=c2dFFNames;
  3086.     while (sIndex[i]!=NULL) i++;
  3087.     
  3088.     return(i);
  3089. }
  3090.  
  3091. /****** meshwriter.library/MWLMeshSave2D ******************************************
  3092. * 
  3093. *   NAME    
  3094. *     MWLMeshSave2D -- Saves the mesh as 2D file.
  3095. *
  3096. *   SYNOPSIS
  3097. *    error = MWLMeshSave2D( meshhandle,id,filename,viewtype,drawmode,taglist )
  3098. *                           D1         D2 D3       D4       D5        A0
  3099. *
  3100. *    ULONG MWLMeshSave2D
  3101. *         ( ULONG,ULONG,STRPTR,ULONG,ULONG,struct TagItem * );
  3102. *
  3103. *   FUNCTION
  3104. *    The mesh, this means vertices, polygons, materials, camera and light will
  3105. *    be used to generate and save a 2D file from a specific view point and
  3106. *    drawing mode.
  3107. * 
  3108. *   INPUTS
  3109. *     meshhandle  - A valid handle of a mesh.
  3110. *    id          - A valid 2D file format id, to specify the output format.
  3111. *    filename    - Name and path of the file.
  3112. *    viewtype    - Type of view, like perspective, or top ...
  3113. *    drawmode    - Type of drawing, points, lines, surfaces ...
  3114. *    taglist     - NULL, for future use.
  3115. *    
  3116. *   RESULT
  3117. *    error - RCNOERROR         if all went well.
  3118. *            RCNOMESH          if the handle is not valid.
  3119. *            RCUNKNOWNFTYPE    if the id is not known.
  3120. *            RCUNKNOWNDMODE    if the view mode in not known.
  3121. *            RCNOPOLYGON       if there are no polygons to save.
  3122. *            RCCHGBUF          if an error occured to allocate the save buffer.
  3123. *            RCWRITEDATA       if an error occured while writing data, no more space...
  3124. *            RCVERTEXOVERFLOW  if the format does not support as much vertices.
  3125. *            IoErr()           if possible to catch it, you will get its codes.
  3126. *
  3127. *   EXAMPLE
  3128. *    error = MWLMeshSave2D(meshhandle,id,"ram:test",TVWPERSP,dm,NULL);
  3129. *
  3130. *   NOTES
  3131. *    No file existence tests are made here! Existent files will be overwritten.
  3132. *
  3133. *   BUGS
  3134. * 
  3135. *   SEE ALSO
  3136. *     MWL2DFileFormatIDGet(),MWLDrawModeGet(),MWLMeshSave3D()
  3137. * 
  3138. ******************************************************************************
  3139. *
  3140. */
  3141. ULONG __saveds ASM MWLMeshSave2D(register __d1 ULONG meshhandle,
  3142.                                     register __d2 ULONG id,
  3143.                                     register __d3 STRPTR filename,
  3144.                                     register __d4 ULONG viewtype,
  3145.                                     register __d5 ULONG drawmode,
  3146.                                     register __a0 struct TagItem *taglist) {
  3147.     TOCLMesh        *mesh;
  3148.     BPTR            filehandle=NULL;
  3149.     ULONG            retcode=RCNOERROR;
  3150.     UBYTE            i;
  3151.     struct TagItem    *mtaglist=NULL;
  3152.     
  3153.     // make a copy of taglist, a0 is a scratch register
  3154.     mtaglist=taglist;
  3155.  
  3156.     mesh = (TOCLMesh *) meshhandle;
  3157.     if(mesh==NULL) return(RCNOMESH);    
  3158.  
  3159.       /*
  3160.       ** If there are no polygons, so leave
  3161.       */
  3162.     if(mesh->polygons.firstNode==NULL) return(RCNOPOLYGON);
  3163.     
  3164.     /*
  3165.     ** Check if the filetype is valid
  3166.     */
  3167.     i=0;
  3168.     while(c2dFFIDs[i]!=id && c2dFFIDs[i]!=0) {i++};
  3169.     if(c2dFFIDs[i]!=id || id==0) return(RCUNKNOWNFTYPE);
  3170.     
  3171.     /*
  3172.     ** Check if the viewtype is valid
  3173.     */
  3174.     if(!(viewtype==TVWTOP ||
  3175.         viewtype==TVWBOTTOM ||
  3176.         viewtype==TVWLEFT ||
  3177.         viewtype==TVWRIGHT ||
  3178.         viewtype==TVWFRONT ||
  3179.         viewtype==TVWBACK ||
  3180.         viewtype==TVWPERSP)) return(RCUNKNOWNVTYPE);
  3181.  
  3182.     /*
  3183.     ** Check if the drawmode is valid
  3184.     */
  3185.     i=0;
  3186.     while(cDMIDs[i]!=drawmode && cDMIDs[i]!=0) {i++};
  3187.     if(cDMIDs[i]!=drawmode || drawmode==0) return(RCUNKNOWNDMODE);
  3188.     
  3189.     /*
  3190.     ** If no camera and light position was given, set it to default now
  3191.     */
  3192.     if (!(mesh->camera.position.x &&
  3193.          mesh->camera.position.y &&
  3194.          mesh->camera.position.z &&
  3195.          mesh->camera.lookat.x &&
  3196.          mesh->camera.lookat.y &&
  3197.          mesh->camera.lookat.z &&
  3198.          mesh->light.position.x &&
  3199.          mesh->light.position.y &&
  3200.          mesh->light.position.z)) setCameraLight(mesh);
  3201.  
  3202.     /*
  3203.     ** Open the file 
  3204.     */
  3205.     /* Open the file for text output */
  3206.     if((filehandle=Open(filename,MODE_NEWFILE))==NULL) return(IoErr());
  3207.  
  3208.     /* Change the buffer size of the filehandle to 10k */
  3209.     if (SetVBuf(filehandle,NULL,BUF_FULL,10000)!=DOSFALSE) {
  3210.         Close(filehandle);
  3211.         return(RCCHGBUF);
  3212.     }
  3213.  
  3214.     /*
  3215.     ** Write the mesh
  3216.     */
  3217.     switch(id) {
  3218. //        case T2DFEPS :
  3219. //            retcode = write2EPS(filehandle,mesh,viewtype,drawmode);
  3220. //            break;        
  3221. //        case T2DFPSP :
  3222. //            retcode = write2PSP(filehandle,mesh,viewtype,drawmode);
  3223. //            break;        
  3224. //        case T2DFPSL :
  3225. //            retcode = write2PSL(filehandle,mesh,viewtype,drawmode);
  3226. //            break;        
  3227.     }
  3228.     
  3229.     /*
  3230.     ** Close the file
  3231.     */
  3232.     Close(filehandle);
  3233.     
  3234.     return(retcode);
  3235. }
  3236.  
  3237. /****** meshwriter.library/MWLDrawModeNamesGet ******************************************
  3238. * 
  3239. *   NAME 
  3240. *        MWLDrawModeNamesGet -- Get a name list of all supported drawing modes.
  3241. * 
  3242. *   SYNOPSIS
  3243. *        list = MWLDrawModeNamesGet(  )
  3244. *
  3245. *        STRPTR * MWLDrawModeNamesGet
  3246. *             (  );
  3247. *
  3248. *   FUNCTION
  3249. *        You will get a pointer to the namelist of all supported drawing modes.
  3250. *        This strings are READ_ONLY and only valid as long as the library is opened.
  3251. *
  3252. *        The resulting pointer can directly be used to fill up cycle or list gadgets
  3253. *        for example.
  3254. *
  3255. *   INPUTS
  3256. *        
  3257. *   RESULT
  3258. *        list - A NULL terminated array of string pointers. Or NULL if no
  3259. *               modes are supported.
  3260. *
  3261. *   EXAMPLE
  3262. *        list = MWLDrawModeNamesGet();
  3263. *
  3264. *   NOTES
  3265. *
  3266. *   BUGS
  3267. * 
  3268. *   SEE ALSO
  3269. *        MWLDrawModeIDGet(),MWLDrawModeNumberOfGet()
  3270. * 
  3271. ******************************************************************************
  3272. *
  3273. */
  3274. STRPTR * __saveds ASM MWLDrawModeNamesGet() {
  3275.     if(cDMNames[0]!=NULL) return(cDMNames);
  3276.     return(NULL);
  3277. }
  3278.  
  3279. /****** meshwriter.library/MWLDrawModeIDGet ******************************************
  3280. * 
  3281. *   NAME 
  3282. *        MWLDrawModeIDGet -- Get the ID of a specific drawing mode.
  3283. * 
  3284. *   SYNOPSIS
  3285. *        id = MWLDrawModeIDGet( dmname )
  3286. *                               D1
  3287. *
  3288. *        ULONG MWLDrawModeIDGet
  3289. *             ( STRPTR );
  3290. *
  3291. *   FUNCTION
  3292. *        You will get the ID of the drawing mode of which you passed its name.
  3293. * 
  3294. *   INPUTS
  3295. *        dm - Name of the drawing mode you search the ID for.
  3296. *        
  3297. *   RESULT
  3298. *        id - The ID of the drawing mode or 0 if not found/supported.
  3299. *
  3300. *   EXAMPLE
  3301. *        id = MWLDrawModeIDGet("Points");
  3302. *
  3303. *   NOTES
  3304. *        Even if the values of the IDs wont change in future versions, it is
  3305. *        recomended to show the list of all names to the user and let him choose
  3306. *        the format. With the help of this function you will get the correct
  3307. *        ID which is needed for further function calls.
  3308. *
  3309. *   BUGS
  3310. * 
  3311. *   SEE ALSO
  3312. *        MWLDrawModeNamesGet(),MWLDrawModeNumberOfGet()
  3313. * 
  3314. ******************************************************************************
  3315. *
  3316. */
  3317. ULONG __saveds ASM MWLDrawModeIDGet(register __d1 STRPTR ffname) {
  3318.     ULONG i;
  3319.     STRPTR mffname=NULL;
  3320.  
  3321.     // make a copy of ffname, d1 is a scratch register
  3322.     mffname=ffname;
  3323.  
  3324.     i=0;
  3325.     while(strcmp(cDMNames[i],mffname) && cDMNames[i]!=NULL) {i++};
  3326.     
  3327.     // check if we got it or not
  3328.     if(!strcmp(cDMNames[i],mffname)) return(cDMIDs[i]);
  3329.     else return(0);
  3330. }
  3331.  
  3332. /****** meshwriter.library/MWLDrawModeNumberOfGet ******************************************
  3333. * 
  3334. *   NAME 
  3335. *        MWLDrawModeNumberOfGet -- Get the number of supported drawing modes.
  3336. * 
  3337. *   SYNOPSIS
  3338. *        number = MWLDrawModeNumberOfGet( )
  3339. *
  3340. *        ULONG MWLDrawModeNumberOfGet
  3341. *             ( );
  3342. *
  3343. *   FUNCTION
  3344. *        You will get the number of supported drawing modes of this library version.
  3345. * 
  3346. *   INPUTS
  3347. *        
  3348. *   RESULT
  3349. *        number - Number of supported drawing modes or 0 if none.
  3350. *
  3351. *   EXAMPLE
  3352. *        number = MWLDrawModeNumberOfGet();
  3353. *
  3354. *   NOTES
  3355. *
  3356. *   BUGS
  3357. * 
  3358. *   SEE ALSO
  3359. *        MWLDrawModeNamesGet(),MWLDrawModeIDGet()
  3360. * 
  3361. ******************************************************************************
  3362. *
  3363. */
  3364. ULONG __saveds ASM MWLDrawModeNumberOfGet() {
  3365.     ULONG  i;
  3366.     STRPTR *sIndex=NULL;
  3367.  
  3368.     i=0;
  3369.     sIndex=cDMNames;
  3370.     while (sIndex[i]!=NULL) i++;
  3371.     
  3372.     return(i);
  3373. }
  3374.  
  3375. /****** meshwriter.library/MWLMeshVertexAdd *************************************************
  3376. * 
  3377. *   NAME    
  3378. *     MWLMeshVertexAdd -- Add a new vertex to the mesh its vertex list according the CTM.
  3379. *
  3380. *   SYNOPSIS
  3381. *    error = MWLMeshVertexAdd( meshhandle,vertex,index )
  3382. *                              D1          A0    D2
  3383. *
  3384. *    ULONG MWLMeshVertexAdd
  3385. *         ( ULONG,TOCLVertex *,ULONG * );
  3386. *
  3387. *   FUNCTION
  3388. *    A new vertex will be added to the mesh its vertex list, without binding it to any
  3389. *    polygon, which can be made later.
  3390. * 
  3391. *   INPUTS
  3392. *     meshhandle   - A valid handle of a mesh.
  3393. *    vertex       - Pointer to a vertex structure which contains the coordinates
  3394. *                   of the new vertex.
  3395. *    index        - Pointer to a variable which will contain the index of the vertex,
  3396. *                   which will be needed for further use.
  3397. *    
  3398. *   RESULT
  3399. *     error - RCNOERROR    if all went well.
  3400. *            RCNOMESH     if the handle is not valid.
  3401. *            RCNOMEMORY   if there is not enough memory. 
  3402. * 
  3403. *   EXAMPLE
  3404. *    error = MWLMeshVertexAdd(meshhandle,&myvertex,&myindex);
  3405. *
  3406. *   NOTES
  3407. *    File formats which have an internal vertex list will get all vertices
  3408. *    of the mesh, even if they were never used in a polygon.
  3409. *
  3410. *   BUGS
  3411. * 
  3412. *   SEE ALSO
  3413. *     MWLMeshPolygonVertexAssign()
  3414. * 
  3415. ******************************************************************************
  3416. *
  3417. */
  3418. ULONG __saveds ASM MWLMeshVertexAdd(register __d1 ULONG meshhandle,
  3419.                                     register __a0 TOCLVertex *vertex,
  3420.                                     register __d2 ULONG *index) {
  3421.                                 
  3422.     TOCLMesh                    *mesh=NULL;
  3423.     TOCLVertexNode                *ver=NULL;
  3424.     TOCLVertex                    *mvertex=NULL;
  3425.       
  3426.     // make a copy of vertex, a0 is a scratch register
  3427.     mvertex=vertex;
  3428.     
  3429.     mesh=(TOCLMesh *) meshhandle;
  3430.     if (mesh==NULL) return(RCNOMESH);
  3431.  
  3432.     /*
  3433.     ** Add a new vertice to the internal vertice list
  3434.     */
  3435.     ver = addVertex(mesh,(*mvertex));
  3436.     if (ver==NULL) {
  3437.         return(RCNOMEMORY);
  3438.     }
  3439.  
  3440.     (*index)=ver->index;
  3441.  
  3442.     return(RCNOERROR);
  3443. }
  3444.  
  3445. /****** meshwriter.library/MWLMeshPolygonVertexAssign ***************************************
  3446. * 
  3447. *   NAME    
  3448. *     MWLMeshPolygonVertexAssign -- Assigns an existing vertex to the most recent polygon.
  3449. *
  3450. *   SYNOPSIS
  3451. *    error = MWLMeshPolygonVertexAssign ( meshhandle,index )
  3452. *                                         D1         D2
  3453. *
  3454. *    ULONG MWLMeshPolygonAssign
  3455. *         ( ULONG,ULONG );
  3456. *
  3457. *   FUNCTION
  3458. *    An already existing vertex will be assigned to the polygon.
  3459. * 
  3460. *   INPUTS
  3461. *     meshhandle   - A valid handle of a mesh.
  3462. *    index        - The index of the vertex.
  3463. *    
  3464. *   RESULT
  3465. *     error - RCNOERROR    if all went well.
  3466. *            RCNOMESH     if the handle is not valid.
  3467. *            RCNOMEMORY   if there is not enough memory. 
  3468. *            RCNOPOLYGON  if there is no polygon to work with.
  3469. *            RCNOVERTEX   if the vertex is not existing.
  3470. * 
  3471. *   EXAMPLE
  3472. *    error = MWLMeshPolygonVertexAssign(meshhandle,index);
  3473. *
  3474. *   NOTES
  3475. *    Vertices have to be assigned in counterclock wise direction.
  3476. *
  3477. *          v3
  3478. *         / |
  3479. *        /  |
  3480. *       /   |
  3481. *      /    |
  3482. *     /     |
  3483. *    v1--->v2
  3484. *
  3485. *
  3486. *   BUGS
  3487. * 
  3488. *   SEE ALSO
  3489. *     MWLMeshVertexAdd()
  3490. * 
  3491. ******************************************************************************
  3492. *
  3493. */
  3494. ULONG __saveds ASM MWLMeshPolygonVertexAssign(register __d1 ULONG meshhandle,
  3495.                                                 register __d2 ULONG index) {
  3496.                                 
  3497.     TOCLMesh                    *mesh=NULL;
  3498.     TOCLVertexNode                *ver=NULL;
  3499.     TOCLPolygonsVerticesNode    *plv=NULL;
  3500.     TOCLPolygonNode            *pln=NULL;
  3501.       
  3502.     mesh=(TOCLMesh *) meshhandle;
  3503.     if (mesh==NULL) return(RCNOMESH);
  3504.  
  3505.     if(mesh->polygons.lastNode==NULL) return(RCNOPOLYGON); /* There is no polygon to work with */
  3506.  
  3507.     ver=getVertex(mesh,index);
  3508.     if(ver==NULL) return(RCNOVERTEX); /* The vertex does not exist */
  3509.  
  3510.     /*
  3511.     ** Add a new polygon vertex node to the polygon list its last element
  3512.     */
  3513.     plv = AllocPooled(mesh->polygonverticespool,sizeof(TOCLPolygonsVerticesNode));
  3514.     if (plv==NULL) {
  3515.         return(RCNOMEMORY);
  3516.     }
  3517.         
  3518.     plv->vertexNode=ver;
  3519.     plv->next=NULL;
  3520.  
  3521.     pln=mesh->polygons.lastNode;
  3522.      
  3523.     if(pln->firstNode!=NULL) {   /* Check if this is the first vertex to insert or not */
  3524.         pln->lastNode->next=plv;
  3525.         pln->lastNode=plv;
  3526.     }
  3527.     else {
  3528.         pln->lastNode=plv;
  3529.         pln->firstNode=plv;
  3530.     }
  3531.     
  3532.     /*
  3533.     ** Increment the number of vertices counter of the polygon
  3534.     */
  3535.     pln->numberOfVertices++;
  3536.         
  3537.     return(RCNOERROR);
  3538. }
  3539.  
  3540. /****** meshwriter.library/MWLMeshCTMReset **********************************************
  3541. * 
  3542. *   NAME    
  3543. *     MWLMeshCTMReset -- Resets the current transformation matrix and the scale.
  3544. *
  3545. *   SYNOPSIS
  3546. *    error = MWLMeshCTMReset( meshhandle )
  3547. *                             D1
  3548. *
  3549. *    ULONG MWLMeshCTMReset
  3550. *         ( ULONG );
  3551. *
  3552. *   FUNCTION
  3553. *    The translation, rotation and scale factors will be set to the default values.
  3554. *    Translation is 0, rotation is 0 and scale is 1, for all axis.
  3555. *
  3556. * 
  3557. *   INPUTS
  3558. *     meshhandle   - A valid handle of a mesh.
  3559. *    
  3560. *   RESULT
  3561. *     error - RCNOERROR          if all went well.
  3562. *            RCNOMESH           if the handle is not valid.
  3563. * 
  3564. *   EXAMPLE
  3565. *    error = MWLMeshCTMReset(meshhandle);
  3566. *
  3567. *   NOTES
  3568. *
  3569. *   BUGS
  3570. * 
  3571. *   SEE ALSO
  3572. *     MWLMeshTranslationChange(), MWLMeshTranslationGet()
  3573. *    MWLMeshRotationChange(),MWLMeshRotationGet()
  3574. *    MWLMeshScaleChange(),MWLMeshScaleGet()
  3575. * 
  3576. ******************************************************************************
  3577. *
  3578. */
  3579. ULONG __saveds ASM MWLMeshCTMReset(register __d1 ULONG meshhandle) {
  3580.     TOCLMesh                    *mesh=NULL;
  3581.       
  3582.     mesh=(TOCLMesh *) meshhandle;
  3583.     if (mesh==NULL) return(RCNOMESH);
  3584.  
  3585.     mesh->ctm.sx=1,mesh->ctm.sy=1,mesh->ctm.sz=1;
  3586.     mesh->ctm.rx=0,mesh->ctm.ry=0,mesh->ctm.rz=0;
  3587.     mesh->ctm.m[0][0]=1,mesh->ctm.m[1][0]=0,mesh->ctm.m[2][0]=0,mesh->ctm.m[3][0]=0;
  3588.     mesh->ctm.m[0][1]=0,mesh->ctm.m[1][1]=1,mesh->ctm.m[2][1]=0,mesh->ctm.m[3][1]=0;
  3589.     mesh->ctm.m[0][2]=0,mesh->ctm.m[1][2]=0,mesh->ctm.m[2][2]=1,mesh->ctm.m[3][2]=0;
  3590.     mesh->ctm.m[0][3]=0,mesh->ctm.m[1][3]=0,mesh->ctm.m[2][3]=0,mesh->ctm.m[3][3]=1;
  3591.     
  3592.     return(RCNOERROR);
  3593. }
  3594.  
  3595. /****** meshwriter.library/MWLMeshTranslationChange *****************************************
  3596. * 
  3597. *   NAME    
  3598. *     MWLMeshTranslationChange -- Changes the translation of the CTM of the mesh.
  3599. *
  3600. *   SYNOPSIS
  3601. *    error = MWLMeshTranslationChange( meshhandle,translation,operation )
  3602. *                                      D1          A0         D2
  3603. *
  3604. *    ULONG MWLMeshTranslationChange
  3605. *         ( ULONG,TOCLVertex *,ULONG );
  3606. *
  3607. *   FUNCTION
  3608. *    The translation of the CTM will be modified in function of the translation
  3609. *    and the operation to perform.
  3610. * 
  3611. *   INPUTS
  3612. *     meshhandle  - A valid handle of a mesh.
  3613. *    translation - Pointer to a vertex structure which contains the coordinates
  3614. *                  of the translation.
  3615. *    operation   - A valid CTM operation.
  3616. *                   CTMADD,CTMSUB,CTMMUL
  3617. *                  CTMDIV,CTMSET,CTMRESET
  3618. *
  3619. *   RESULT
  3620. *     error - RCNOERROR          if all went well.
  3621. *            RCNOMESH           if the handle is not valid.
  3622. *            RCINVALIDOPERATION if the operation is not value.
  3623. * 
  3624. *   EXAMPLE
  3625. *    error = MWLMeshTranslationChange(meshhandle,&mytranslation,myoperation);
  3626. *
  3627. *   NOTES
  3628. *    If you pass 0 values for a division operation,
  3629. *    the corresponding CTM entry will be set to 0.
  3630. *
  3631. *   BUGS
  3632. * 
  3633. *   SEE ALSO
  3634. *     MWLMeshCTMReset(), MWLMeshTranslationGet()
  3635. *    MWLMeshRotationChange(),MWLMeshRotationGet()
  3636. *    MWLMeshScaleChange(),MWLMeshScaleGet()
  3637. * 
  3638. ******************************************************************************
  3639. *
  3640. */
  3641. ULONG __saveds ASM MWLMeshTranslationChange(register __d1 ULONG meshhandle,
  3642.                                             register __a0 TOCLVertex *translation,
  3643.                                             register __d2 ULONG operation) {
  3644.                                 
  3645.     TOCLMesh    *mesh=NULL;
  3646.     TOCLVertex    *tvertex=NULL;
  3647.       
  3648.     // make a copy of translation vertex, a0 is a scratch register
  3649.     tvertex=translation;
  3650.     
  3651.     mesh=(TOCLMesh *) meshhandle;
  3652.     if (mesh==NULL) return(RCNOMESH);
  3653.  
  3654.     switch (operation) {
  3655.         case CTMADD :
  3656.             mesh->ctm.m[3][0]+=tvertex->x;
  3657.             mesh->ctm.m[3][1]+=tvertex->y;
  3658.             mesh->ctm.m[3][2]+=tvertex->z;
  3659.         break;
  3660.         case CTMSUB :
  3661.             mesh->ctm.m[3][0]-=tvertex->x;
  3662.             mesh->ctm.m[3][1]-=tvertex->y;
  3663.             mesh->ctm.m[3][2]-=tvertex->z;
  3664.         break;
  3665.         case CTMMUL :
  3666.             mesh->ctm.m[3][0]*=tvertex->x;
  3667.             mesh->ctm.m[3][1]*=tvertex->y;
  3668.             mesh->ctm.m[3][2]*=tvertex->z;
  3669.         break;
  3670.         case CTMDIV :
  3671.             if(tvertex->x!=0) mesh->ctm.m[3][0]/=tvertex->x;
  3672.             else mesh->ctm.m[3][0]=0;
  3673.             if(tvertex->y!=0) mesh->ctm.m[3][1]/=tvertex->y;
  3674.             else mesh->ctm.m[3][1]=0;
  3675.             if(tvertex->z!=0) mesh->ctm.m[3][2]/=tvertex->z;
  3676.             else mesh->ctm.m[3][2]=0;
  3677.         break;
  3678.         case CTMSET :
  3679.             mesh->ctm.m[3][0]=tvertex->x;
  3680.             mesh->ctm.m[3][1]=tvertex->y;
  3681.             mesh->ctm.m[3][2]=tvertex->z;
  3682.         break;
  3683.         case CTMRESET :
  3684.             mesh->ctm.m[3][0]=0;
  3685.             mesh->ctm.m[3][1]=0;
  3686.             mesh->ctm.m[3][2]=0;
  3687.             mesh->ctm.m[3][3]=1;
  3688.         break;
  3689.         default :
  3690.             return(RCINVALIDOPERATION);
  3691.     }
  3692.  
  3693.     return(RCNOERROR);
  3694. }
  3695.  
  3696. /****** meshwriter.library/MWLMeshTranslationGet ********************************************
  3697. * 
  3698. *   NAME    
  3699. *     MWLMeshTranslationGet -- Get the translation of the mesh its CTM.
  3700. *
  3701. *   SYNOPSIS
  3702. *    error = MWLMeshTranslationGet( meshhandle,translation )
  3703. *                                   D1          A0
  3704. *
  3705. *    ULONG MWLMeshTranslationGet
  3706. *         ( ULONG,TOCLVertex * );
  3707. *
  3708. *   FUNCTION
  3709. *    The translation of the CTM will be returned in the passed vertex structure.
  3710. * 
  3711. *   INPUTS
  3712. *     meshhandle  - A valid handle of a mesh.
  3713. *    translation - Pointer to a vertex structure which will contain the translation.
  3714. *
  3715. *   RESULT
  3716. *     error - RCNOERROR          if all went well.
  3717. *            RCNOMESH           if the handle is not valid.
  3718. * 
  3719. *   EXAMPLE
  3720. *    error = MWLMeshTranslationGet(meshhandle,&mytranslation);
  3721. *
  3722. *   NOTES
  3723. *
  3724. *   BUGS
  3725. * 
  3726. *   SEE ALSO
  3727. *     MWLMeshCTMReset(), MWLMeshTranslationChange()
  3728. *    MWLMeshRotationChange(),MWLMeshRotationGet()
  3729. *    MWLMeshScaleChange(),MWLMeshScaleGet()
  3730. * 
  3731. ******************************************************************************
  3732. *
  3733. */
  3734. ULONG __saveds ASM MWLMeshTranslationGet(register __d1 ULONG meshhandle,
  3735.                                             register __a0 TOCLVertex *translation) {
  3736.                                 
  3737.     TOCLMesh    *mesh=NULL;
  3738.     TOCLVertex    *tvertex=NULL;
  3739.       
  3740.     // make a copy of translation vertex, a0 is a scratch register
  3741.     tvertex=translation;
  3742.     
  3743.     mesh=(TOCLMesh *) meshhandle;
  3744.     if (mesh==NULL) return(RCNOMESH);
  3745.  
  3746.     tvertex->x=mesh->ctm.m[3][0];
  3747.     tvertex->y=mesh->ctm.m[3][1];
  3748.     tvertex->z=mesh->ctm.m[3][2];
  3749.     
  3750.     return(RCNOERROR);
  3751. }
  3752.  
  3753. /****** meshwriter.library/MWLMeshScaleChange ***********************************************
  3754. * 
  3755. *   NAME    
  3756. *     MWLMeshScaleChange -- Changes the scale of the CTM of the mesh.
  3757. *
  3758. *   SYNOPSIS
  3759. *    error = MWLMeshScaleChange( meshhandle,scale,operation )
  3760. *                                D1          A0   D2
  3761. *
  3762. *    ULONG MWLMeshScaleChange
  3763. *         ( ULONG,TOCLVertex *,ULONG );
  3764. *
  3765. *   FUNCTION
  3766. *    The scale of the CTM will be modified in function of the scale
  3767. *    and the operation to perform.
  3768. * 
  3769. *   INPUTS
  3770. *     meshhandle  - A valid handle of a mesh.
  3771. *    scale       - Pointer to a vertex structure which contains the factor
  3772. *                  of the scaling.
  3773. *    operation   - A valid CTM operation.
  3774. *                   CTMADD,CTMSUB,CTMMUL
  3775. *                  CTMDIV,CTMSET,CTMRESET
  3776. *
  3777. *   RESULT
  3778. *     error - RCNOERROR          if all went well.
  3779. *            RCNOMESH           if the handle is not valid.
  3780. *            RCINVALIDOPERATION if the operation is not value.
  3781. * 
  3782. *   EXAMPLE
  3783. *    error = MWLMeshScaleChange(meshhandle,&myscale,myoperation);
  3784. *
  3785. *   NOTES
  3786. *    If you pass 0 values for a division operation,
  3787. *    the corresponding CTM entry will be set to 0.
  3788. *
  3789. *   BUGS
  3790. * 
  3791. *   SEE ALSO
  3792. *     MWLMeshTranslationChange(), MWLMeshTranslationGet()
  3793. *    MWLMeshRotationChange(),MWLMeshRotationGet()
  3794. *    MWLMeshCTMReset(),MWLMeshScaleGet()
  3795. * 
  3796. ******************************************************************************
  3797. *
  3798. */
  3799. ULONG __saveds ASM MWLMeshScaleChange(register __d1 ULONG meshhandle,
  3800.                                             register __a0 TOCLVertex *scale,
  3801.                                             register __d2 ULONG operation) {
  3802.                                 
  3803.     TOCLMesh    *mesh=NULL;
  3804.     TOCLVertex    *svertex=NULL;
  3805.       
  3806.     // make a copy of scale vertex, a0 is a scratch register
  3807.     svertex=scale;
  3808.     
  3809.     mesh=(TOCLMesh *) meshhandle;
  3810.     if (mesh==NULL) return(RCNOMESH);
  3811.  
  3812.     switch (operation) {
  3813.         case CTMADD :
  3814.             mesh->ctm.sx+=svertex->x;
  3815.             mesh->ctm.sy+=svertex->y;
  3816.             mesh->ctm.sz+=svertex->z;
  3817.         break;
  3818.         case CTMSUB :
  3819.             mesh->ctm.sx-=svertex->x;
  3820.             mesh->ctm.sy-=svertex->y;
  3821.             mesh->ctm.sz-=svertex->z;
  3822.         break;
  3823.         case CTMMUL :
  3824.             mesh->ctm.sx*=svertex->x;
  3825.             mesh->ctm.sy*=svertex->y;
  3826.             mesh->ctm.sz*=svertex->z;
  3827.         break;
  3828.         case CTMDIV :
  3829.             if(svertex->x!=0) mesh->ctm.sx/=svertex->x;
  3830.             else mesh->ctm.sx=0;
  3831.             if(svertex->y!=0) mesh->ctm.sy/=svertex->y;
  3832.             else mesh->ctm.sy=0;
  3833.             if(svertex->z!=0) mesh->ctm.sz/=svertex->z;
  3834.             else mesh->ctm.sz=0;
  3835.         break;
  3836.         case CTMSET :
  3837.             mesh->ctm.sx=svertex->x;
  3838.             mesh->ctm.sy=svertex->y;
  3839.             mesh->ctm.sz=svertex->z;
  3840.         break;
  3841.         case CTMRESET :
  3842.             mesh->ctm.sx=1;
  3843.             mesh->ctm.sy=1;
  3844.             mesh->ctm.sz=1;
  3845.         break;
  3846.         default :
  3847.             return(RCINVALIDOPERATION);
  3848.     }
  3849.  
  3850.     return(RCNOERROR);
  3851. }
  3852.  
  3853. /****** meshwriter.library/MWLMeshScaleGet **************************************************
  3854. * 
  3855. *   NAME    
  3856. *     MWLMeshScaleGet -- Get the scale of the mesh its CTM.
  3857. *
  3858. *   SYNOPSIS
  3859. *    error = MWLMeshScaleGet( meshhandle,scale )
  3860. *                             D1          A0
  3861. *
  3862. *    ULONG MWLMeshScaleGet
  3863. *         ( ULONG,TOCLVertex * );
  3864. *
  3865. *   FUNCTION
  3866. *    The scale of the CTM will be returned in the passed vertex structure.
  3867. * 
  3868. *   INPUTS
  3869. *     meshhandle  - A valid handle of a mesh.
  3870. *    scale       - Pointer to a vertex structure which will contain the scale factors.
  3871. *
  3872. *   RESULT
  3873. *     error - RCNOERROR          if all went well.
  3874. *            RCNOMESH           if the handle is not valid.
  3875. * 
  3876. *   EXAMPLE
  3877. *    error = MWLMeshScaleGet(meshhandle,&myscale);
  3878. *
  3879. *   NOTES
  3880. *
  3881. *   BUGS
  3882. * 
  3883. *   SEE ALSO
  3884. *     MWLMeshTranslationChange(), MWLMeshTranslationChange()
  3885. *    MWLMeshRotationChange(),MWLMeshRotationGet()
  3886. *    MWLMeshScaleChange(),MWLMeshCTMReset()
  3887. * 
  3888. ******************************************************************************
  3889. *
  3890. */
  3891. ULONG __saveds ASM MWLMeshScaleGet(register __d1 ULONG meshhandle,
  3892.                                     register __a0 TOCLVertex *scale) {
  3893.                                 
  3894.     TOCLMesh    *mesh=NULL;
  3895.     TOCLVertex    *svertex=NULL;
  3896.       
  3897.     // make a copy of scale vertex, a0 is a scratch register
  3898.     svertex=scale;
  3899.     
  3900.     mesh=(TOCLMesh *) meshhandle;
  3901.     if (mesh==NULL) return(RCNOMESH);
  3902.  
  3903.     svertex->x=mesh->ctm.sx;
  3904.     svertex->y=mesh->ctm.sy;
  3905.     svertex->z=mesh->ctm.sz;
  3906.     
  3907.     return(RCNOERROR);
  3908. }
  3909.  
  3910. /****** meshwriter.library/MWLMeshRotationChange ********************************************
  3911. * 
  3912. *   NAME    
  3913. *     MWLMeshRotationChange -- Changes the rotation of the CTM of the mesh.
  3914. *
  3915. *   SYNOPSIS
  3916. *    error = MWLMeshRotationChange( meshhandle,rotation,operation )
  3917. *                                   D1          A0      D2
  3918. *
  3919. *    ULONG MWLMeshRotationChange
  3920. *         ( ULONG,TOCLVertex *,ULONG );
  3921. *
  3922. *   FUNCTION
  3923. *    The rotation of the CTM will be modified in function of the rotation
  3924. *    and the operation to perform.
  3925. * 
  3926. *   INPUTS
  3927. *     meshhandle - A valid handle of a mesh.
  3928. *    rotation   - Pointer to a vertex structure which contains the angles in radian
  3929. *                 of the rotation.
  3930. *    operation  - A valid CTM operation.
  3931. *                  CTMADD,CTMSUB,CTMMUL
  3932. *                 CTMDIV,CTMSET,CTMRESET
  3933. *
  3934. *   RESULT
  3935. *     error - RCNOERROR          if all went well.
  3936. *            RCNOMESH           if the handle is not valid.
  3937. *            RCINVALIDOPERATION if the operation is not value.
  3938. * 
  3939. *   EXAMPLE
  3940. *    error = MWLMeshRotationChange(meshhandle,&myrotation,myoperation);
  3941. *
  3942. *   NOTES
  3943. *    If you pass 0 values for a division operation,
  3944. *    the corresponding CTM entry will be set to 0.
  3945. *
  3946. *   BUGS
  3947. * 
  3948. *   SEE ALSO
  3949. *     MWLMeshTranslationChange(), MWLMeshTranslationGet()
  3950. *    MWLMeshCTMReset(),MWLMeshRotationGet()
  3951. *    MWLMeshScaleChange(),MWLMeshScaleGet()
  3952. * 
  3953. ******************************************************************************
  3954. *
  3955. */
  3956. ULONG __saveds ASM MWLMeshRotationChange(register __d1 ULONG meshhandle,
  3957.                                             register __a0 TOCLVertex *rotation,
  3958.                                             register __d2 ULONG operation) {
  3959.                                 
  3960.     TOCLMesh    *mesh=NULL;
  3961.     TOCLVertex    *rvertex=NULL;
  3962.     double        m1[3][3],m2[3][3];
  3963.       
  3964.     // make a copy of rotation vertex, a0 is a scratch register
  3965.     rvertex=rotation;
  3966.     
  3967.     mesh=(TOCLMesh *) meshhandle;
  3968.     if (mesh==NULL) return(RCNOMESH);
  3969.  
  3970.     switch (operation) {
  3971.         case CTMADD :
  3972.             mesh->ctm.rx+=rvertex->x;
  3973.             mesh->ctm.ry+=rvertex->y;
  3974.             mesh->ctm.rz+=rvertex->z;
  3975.         break;
  3976.         case CTMSUB :
  3977.             mesh->ctm.rx-=rvertex->x;
  3978.             mesh->ctm.ry-=rvertex->y;
  3979.             mesh->ctm.rz-=rvertex->z;
  3980.         break;
  3981.         case CTMMUL :
  3982.             mesh->ctm.rx*=rvertex->x;
  3983.             mesh->ctm.ry*=rvertex->y;
  3984.             mesh->ctm.rz*=rvertex->z;
  3985.         break;
  3986.         case CTMDIV :
  3987.             if(rvertex->x!=0) mesh->ctm.rx/=rvertex->x;
  3988.             else mesh->ctm.rx=0;
  3989.             if(rvertex->y!=0) mesh->ctm.ry/=rvertex->y;
  3990.             else mesh->ctm.ry=0;
  3991.             if(rvertex->z!=0) mesh->ctm.rz/=rvertex->z;
  3992.             else mesh->ctm.rz=0;
  3993.         break;
  3994.         case CTMSET :
  3995.             mesh->ctm.rx=rvertex->x;
  3996.             mesh->ctm.ry=rvertex->y;
  3997.             mesh->ctm.rz=rvertex->z;
  3998.         break;
  3999.         case CTMRESET :
  4000.             mesh->ctm.rx=0;
  4001.             mesh->ctm.ry=0;
  4002.             mesh->ctm.rz=0;
  4003.         break;
  4004.         default :
  4005.             return(RCINVALIDOPERATION);
  4006.     }
  4007.  
  4008.     // If equal to 2*PI set to 0
  4009.     if(mesh->ctm.rx==2*PI) mesh->ctm.rx=0;
  4010.     if(mesh->ctm.ry==2*PI) mesh->ctm.ry=0;
  4011.     if(mesh->ctm.rz==2*PI) mesh->ctm.rz=0;
  4012.  
  4013.     // Recalculating the CTM
  4014.     m1[0][0]=1;
  4015.     m1[1][0]=0;
  4016.     m1[2][0]=0;
  4017.     m1[0][1]=0;
  4018.     m1[1][1]=1;
  4019.     m1[2][1]=0;
  4020.     m1[0][2]=0;
  4021.     m1[1][2]=0;
  4022.     m1[2][2]=1;
  4023.  
  4024.     m2[0][0]=cos(mesh->ctm.rz);
  4025.     m2[1][0]=-sin(mesh->ctm.rz);
  4026.     m2[2][0]=0;
  4027.     m2[0][1]=sin(mesh->ctm.rz);
  4028.     m2[1][1]=cos(mesh->ctm.rz);
  4029.     m2[2][1]=0;
  4030.     m2[0][2]=0;
  4031.     m2[1][2]=0;
  4032.     m2[2][2]=1;
  4033.  
  4034.     mulMatrix(m1,m2);
  4035.  
  4036.     m2[0][0]=cos(mesh->ctm.ry);
  4037.     m2[1][0]=0;
  4038.     m2[2][0]=sin(mesh->ctm.ry);
  4039.     m2[0][1]=0;
  4040.     m2[1][1]=1;
  4041.     m2[2][1]=0;
  4042.     m2[0][2]=-sin(mesh->ctm.ry);
  4043.     m2[1][2]=0;
  4044.     m2[2][2]=cos(mesh->ctm.ry);
  4045.  
  4046.     mulMatrix(m1,m2);
  4047.  
  4048.     m2[0][0]=1;
  4049.     m2[1][0]=0;
  4050.     m2[2][0]=0;
  4051.     m2[0][1]=0;
  4052.     m2[1][1]=cos(mesh->ctm.rx);
  4053.     m2[2][1]=-sin(mesh->ctm.rx);
  4054.     m2[0][2]=0;
  4055.     m2[1][2]=sin(mesh->ctm.rx);
  4056.     m2[2][2]=cos(mesh->ctm.rx);
  4057.  
  4058.     mulMatrix(m1,m2);
  4059.  
  4060.     mesh->ctm.m[0][0]=(TOCLFloat)m1[0][0];
  4061.     mesh->ctm.m[1][0]=(TOCLFloat)m1[1][0];
  4062.     mesh->ctm.m[2][0]=(TOCLFloat)m1[2][0];
  4063.     mesh->ctm.m[0][1]=(TOCLFloat)m1[0][1];
  4064.     mesh->ctm.m[1][1]=(TOCLFloat)m1[1][1];
  4065.     mesh->ctm.m[2][1]=(TOCLFloat)m1[2][1];
  4066.     mesh->ctm.m[0][2]=(TOCLFloat)m1[0][2];
  4067.     mesh->ctm.m[1][2]=(TOCLFloat)m1[1][2];
  4068.     mesh->ctm.m[2][2]=(TOCLFloat)m1[2][2];
  4069.  
  4070.     return(RCNOERROR);
  4071. }
  4072.  
  4073. /****** meshwriter.library/MWLMeshRotationGet ***********************************************
  4074. * 
  4075. *   NAME    
  4076. *     MWLMeshRotationGet -- Get the rotation of the mesh its CTM.
  4077. *
  4078. *   SYNOPSIS
  4079. *    error = MWLMeshRotationGet( meshhandle,rotation )
  4080. *                                D1          A0
  4081. *
  4082. *    ULONG MWLMeshRotationGet
  4083. *         ( ULONG,TOCLVertex * );
  4084. *
  4085. *   FUNCTION
  4086. *    The rotation of the CTM will be returned in the passed vertex structure.
  4087. * 
  4088. *   INPUTS
  4089. *     meshhandle - A valid handle of a mesh.
  4090. *    rotation   - Pointer to a vertex structure which will contain the
  4091. *                 rotation angles in radian.
  4092. *
  4093. *   RESULT
  4094. *     error - RCNOERROR          if all went well.
  4095. *            RCNOMESH           if the handle is not valid.
  4096. * 
  4097. *   EXAMPLE
  4098. *    error = MWLMeshRotationGet(meshhandle,&myrotation);
  4099. *
  4100. *   NOTES
  4101. *
  4102. *   BUGS
  4103. * 
  4104. *   SEE ALSO
  4105. *     MWLMeshtranslationChange(), MWLMeshTranslationChange()
  4106. *    MWLMeshRotationChange(),MWLMeshCTMReset()
  4107. *    MWLMeshScaleChange(),MWLMeshScaleGet()
  4108. * 
  4109. ******************************************************************************
  4110. *
  4111. */
  4112. ULONG __saveds ASM MWLMeshRotationGet(register __d1 ULONG meshhandle,
  4113.                                         register __a0 TOCLVertex *rotation) {
  4114.                                 
  4115.     TOCLMesh    *mesh=NULL;
  4116.     TOCLVertex    *rvertex=NULL;
  4117.       
  4118.     // make a copy of rotation vertex, a0 is a scratch register
  4119.     rvertex=rotation;
  4120.     
  4121.     mesh=(TOCLMesh *) meshhandle;
  4122.     if (mesh==NULL) return(RCNOMESH);
  4123.  
  4124.     rvertex->x=mesh->ctm.rx;
  4125.     rvertex->y=mesh->ctm.ry;
  4126.     rvertex->z=mesh->ctm.rz;
  4127.     
  4128.     return(RCNOERROR);
  4129. }
  4130. /****** meshwriter.library/MWLMeshMaterialDiffuseColorSet ******************************************
  4131. * 
  4132. *   NAME    
  4133. *     MWLMeshMaterialDiffuseColorSet -- Set the diffuse color of a material.
  4134. * 
  4135. *   SYNOPSIS
  4136. *    error = MWLMeshMaterialDiffuseColorSet( meshhandle,materialhandle,color )
  4137. *                                            D1         D2              A0
  4138. *
  4139. *    ULONG MWLMeshMaterialDiffuseColorSet
  4140. *         ( ULONG,ULONG,TOCLColor * );
  4141. *
  4142. *   FUNCTION
  4143. *    The diffuse color of the material will be set to the values passed by the
  4144. *    color structure.
  4145. * 
  4146. *   INPUTS
  4147. *     meshhandle      - A valid handle of a mesh.
  4148. *    materialhandle  - A valid handle of a material.
  4149. *    color           - Pointer to a color structure containing the color information.
  4150. *    
  4151. *   RESULT
  4152. *     error - RCNOERROR    if all went well.
  4153. *            RCNOMESH     if the handle is not valid.
  4154. *            RCNOMATERIAL if the handle is not valid.
  4155. *
  4156. *   EXAMPLE
  4157. *    error = MWLMeshMaterialDiffuseColorSet(meshhandle,materialhandle,&mycolor);
  4158. *
  4159. *   NOTES
  4160. *
  4161. *   BUGS
  4162. * 
  4163. *   SEE ALSO
  4164. *     MWLMeshMaterialDiffuseColorGet()
  4165. * 
  4166. ******************************************************************************
  4167. *
  4168. */
  4169. ULONG __saveds ASM MWLMeshMaterialDiffuseColorSet(register __d1 ULONG meshhandle,
  4170.                                                         register __d2 ULONG materialhandle,
  4171.                                                         register __a0 TOCLColor *color) {
  4172.     TOCLMesh            *mesh=NULL;
  4173.     TOCLMaterialNode    *mat=NULL;
  4174.     TOCLColor            *mcolor=NULL;
  4175.  
  4176.     // make a copy of color, because a0 is a scratch register
  4177.     mcolor = color;
  4178.     
  4179.     mesh=(TOCLMesh *) meshhandle;
  4180.     if(mesh==NULL) return(RCNOMESH);
  4181.   
  4182.     mat=getMaterialNode(mesh,materialhandle);
  4183.     if(mat==NULL) return(RCNOMATERIAL);
  4184.   
  4185.     mat->diffuseColor=(*mcolor);
  4186.     
  4187.     return(RCNOERROR);
  4188. }
  4189.  
  4190. /****** meshwriter.library/MWLMeshMaterialDiffuseColorGet ******************************************
  4191. * 
  4192. *   NAME    
  4193. *     MWLMeshMaterialDiffuseColorGet -- Get the diffuse color of a material.
  4194. * 
  4195. *   SYNOPSIS
  4196. *    error = MWLMeshMaterialDiffuseColorGet( meshhandle,materialhandle,color )
  4197. *                                            D1         D2              A0
  4198. *
  4199. *    ULONG MWLMeshMaterialDiffuseColorGet
  4200. *         ( ULONG,ULONG,TOCLColor * );
  4201. *
  4202. *   FUNCTION
  4203. *    The diffuse color of the material will be written in the passed color structure.
  4204. * 
  4205. *   INPUTS
  4206. *     meshhandle      - A valid handle of a mesh.
  4207. *    materialhandle  - A valid handle of a material.
  4208. *    color           - Pointer to a color structure which will contain
  4209. *                      the color information.
  4210. *    
  4211. *   RESULT
  4212. *     error - RCNOERROR    if all went well.
  4213. *            RCNOMESH     if the handle is not valid.
  4214. *            RCNOMATERIAL if the handle is not valid.
  4215. *
  4216. *   EXAMPLE
  4217. *    error = MWLMeshMaterialDiffuseColorGet(meshhandle,materialhandle,&mycolor);
  4218. *
  4219. *   NOTES
  4220. *
  4221. *   BUGS
  4222. * 
  4223. *   SEE ALSO
  4224. *     MWLMeshMaterialDiffuseColorSet()
  4225. * 
  4226. ******************************************************************************
  4227. *
  4228. */
  4229. ULONG __saveds ASM MWLMeshMaterialDiffuseColorGet(register __d1 ULONG meshhandle,
  4230.                                                         register __d2 ULONG materialhandle,
  4231.                                                         register __a0 TOCLColor *color) {
  4232.     TOCLMesh            *mesh=NULL;
  4233.     TOCLMaterialNode    *mat=NULL;
  4234.     TOCLColor            *mcolor=NULL;
  4235.     
  4236.     // make a copy of color, a0 is a scratch register
  4237.     mcolor=color;
  4238.     
  4239.     mesh=(TOCLMesh *) meshhandle;
  4240.     if(mesh==NULL) return(RCNOMESH);
  4241.   
  4242.     mat=getMaterialNode(mesh,materialhandle);
  4243.     if(mat==NULL) return(RCNOMATERIAL);
  4244.   
  4245.     (*mcolor)=mat->diffuseColor;
  4246.     
  4247.     return(RCNOERROR);
  4248. }
  4249.  
  4250. /*
  4251. TODO
  4252.  
  4253. Lightwave,Imagine,Videoscape  groessen/anzahl checks fertigmachen !!
  4254.  
  4255. Material mehr parameter, brechungsindex, reflektion, ...
  4256.  
  4257. */
  4258.  
  4259. /************************* End of file ******************************/
  4260.  
  4261.